Ruby Object Database

The Ruby Object Database is not really to be database per se, but rather a set of components that work with each other to allow data to be stored, retrieved, and modified in a way that makes sense for each datatype. I'm writing this to allow rich datatypes (weblogs, diaries, contact lists, etc.) to be dealt with within the framework of a persistent, permission-validated community structure. Once the strucure is in place (along with its setting and getting calls), the datatypes that are added to it can be accessed and dealt with in a predictable and safe way.
The goals of the Ruby Object Database project currently are:
  1. Provide an object datastore accessible over a network
  2. Make sure that database maintains the state of its objects
  3. Make sure the data store does not use too much RAM.
  4. Make access control hierarchies a core part of the datastore.
  5. Make the datastore available from any language using existing standards.
The datastore mentioned in item 1 is a ruby version of Object Prevalence, which is an object system in-memory whose state is preserved by journalling changes to the object set to file. When the datastore is shut down then restarted its state is brought up-to-date by processing the log file (item 2). The goal of the in-memory datastore is to maintain state, not to try to put all data in memory (item 3). Therefore, a mechanism for using disk-based storage will be set up, probably using the Berkeley database, which is fast and small. This will allow for data important for an object but not vital to the interconnection between objects to be sent to disk storeage. Item 4 will be adhered to by setting up each object to be associated with node objects, each of which has its own set of access controls. The fifth goal will be done using an XML-RPC gateway (Soap is easy enough as well). The trick to the remote procedure calling protocols is that they're just stubs allowing the data to be accessed in a safe way. A sample XML-RPC call in Ruby might look like this: 
require 'xmlrpc/client'

server, mount, port = 'localhost', '/RPC2', 80
username, pword = "imarsman", "secret"
args = ["person","get_name", username, password]

begin
  s = XMLRPC::Client.new(server, mount, port)
  res = s.call("call",*args)
  puts "fname: #{res['fname']} lname: #{res['lname']}"
rescue XMLRPC::FaultException
  puts "Error"
rescue TimeoutError
  puts "Timeout Error"
end

Here's the hierarchy for the system: 

 ----------------
| XML-RPC Client |    - From any language (PHP, Java, .Net, Perl...)
 ----------------
        |
 ----------------  _
| XML-RPC Server |  |
 ----------------   |
        |           |- running from Apache using mod_ruby
 --------------     |
| dRuby Client |    |
 --------------    -
        |
 --------------    --------------  _
| dRuby Server |--| in-memory db |  |
 --------------    --------------   |
                         |          |- In separate process
                   -------------    |
                  | Berkeley DB |   |
                   -------------   -

Status

I have assembled a list of

Components

Ruby
workflow classes (Torrent)
mod_ruby
xml parser (nqxml)
xml-rpc server/client
Distributed Ruby (dRuby) classes
Object Prevalence classes (mnemonic)

Todo