Much progress, though not perfect, on migrating to SQLAlchemy 0.4 and Elixir

0.4.  Lots of things changes, which broke lots of our code.  There are still a
couple of failures in the test suite that I don't understand.  It seems that
for pending.txt and requests.txt, sometimes strings come back from the
database as 8-bit strings and other times as unicodes.  It's impossible to
make these tests work both separately and together.

users.txt is also failing intermittently.  Lots of different behavior between
running the full test suite all together and running individual tests.  Sigh.

Note also that actually, Elixir 0.4.0 doesn't work for us.  There's a bug in
that version that prevented zope.interfaces and Elixir working together.  Get
the latest 0.4.0 from source to fix this.

Other changes include:

- Remove Mailman/lockfile.py.  While I haven't totally eliminated locking, I
  have released the lockfile as a separate Python package called locknix,
  which Mailman 3.0 now depends on.

- Renamed Mailman/interfaces/messagestore.py and added an IMessage interface.

- bin/testall raises turns on SQLALCHEMY_ECHO when the verbosity is above 3
  (that's three -v's because the default verbosity is 1).

- add_domain() in config files now allows url_host to be optional.  If not
  given, it defaults to email_host.

- Added a non-public interface IDatabase._reset() used by the test suite to
  zap the database between doctests.  Added an implementation in the model
  which just runs through all rows in all entities, deleting them.

- [I]Pending renamed to [I]Pended

- Don't allow Pendings.add() to infloop.

- In the model's User impelementations, we don't need to append or remove the
  address when linking and unlinking.  By setting the address.user attribute,
  SQLAlchemy appears to do the right thing, though I'm not 100% sure of that
  (see the above mentioned failures).

39 files changed, 431 insertions, 1022 deletions

diff --git a/Mailman/Archiver/HyperArch.py b/Mailman/Archiver/HyperArch.py
index 7ce0905ca..97d608993 100644
--- a/Mailman/Archiver/HyperArch.py
+++ b/Mailman/Archiver/HyperArch.py
@@ -41,12 +41,12 @@ import binascii
 from email.Charset import Charset
 from email.Errors import HeaderParseError
 from email.Header import decode_header, make_header
+from locknix.lockfile import Lock
 
 from Mailman import Errors
 from Mailman import MailList
 from Mailman import Utils
 from Mailman import i18n
-from Mailman import lockfile
 from Mailman.Archiver import HyperDatabase
 from Mailman.Archiver import pipermail
 from Mailman.Mailbox import ArchiverMailbox
@@ -604,9 +604,6 @@ class HyperArchive(pipermail.T):
 
     def __init__(self, maillist):
         # can't init the database while other processes are writing to it!
-        # XXX TODO- implement native locking
-        # with mailman's LockFile module for HyperDatabase.HyperDatabase
-        #
         dir = maillist.archive_dir()
         db = HyperDatabase.HyperDatabase(dir, maillist)
         self.__super_init(dir, reload=1, database=db)
@@ -786,7 +783,7 @@ class HyperArchive(pipermail.T):
     def GetArchLock(self):
         if self._lock_file:
             return 1
-        self._lock_file = lockfile.LockFile(
+        self._lock_file = Lock(
             os.path.join(config.LOCK_DIR,
                          self.maillist.fqdn_listname + '-arch.lock'))
         try:
diff --git a/Mailman/Archiver/HyperDatabase.py b/Mailman/Archiver/HyperDatabase.py
index 3644fbc58..b1d0ec25b 100644
--- a/Mailman/Archiver/HyperDatabase.py
+++ b/Mailman/Archiver/HyperDatabase.py
@@ -27,7 +27,7 @@ import errno
 # package/project modules
 #
 import pipermail
-from Mailman.lockfile import LockFile
+from locknix import lockfile
 
 CACHESIZE = pipermail.CACHESIZE
 
@@ -58,7 +58,7 @@ class DumbBTree:
     def __init__(self, path):
         self.current_index = 0
         self.path = path
-        self.lockfile = LockFile(self.path + ".lock")
+        self.lockfile = lockfile.Lock(self.path + ".lock")
         self.lock()
         self.__dirty = 0
         self.dict = {}
@@ -80,7 +80,7 @@ class DumbBTree:
     def unlock(self):
         try:
             self.lockfile.unlock()
-        except LockFile.NotLockedError:
+        except lockfile.NotLockedError:
             pass
 
     def __delitem__(self, item):
diff --git a/Mailman/Handlers/Scrubber.py b/Mailman/Handlers/Scrubber.py
index 3f29fc02b..bb607b1d2 100644
--- a/Mailman/Handlers/Scrubber.py
+++ b/Mailman/Handlers/Scrubber.py
@@ -29,12 +29,12 @@ import binascii
 import tempfile
 
 from cStringIO import StringIO
-from mimetypes import guess_all_extensions
-
 from email.charset import Charset
 from email.generator import Generator
 from email.parser import HeaderParser
 from email.utils import make_msgid, parsedate
+from locknix.lockfile import Lock
+from mimetypes import guess_all_extensions
 
 from Mailman import Message
 from Mailman import Utils
@@ -42,7 +42,6 @@ from Mailman.Errors import DiscardMessage
 from Mailman.app.archiving import get_base_archive_url
 from Mailman.configuration import config
 from Mailman.i18n import _
-from Mailman.lockfile import LockFile
 
 # Path characters for common platforms
 pre = re.compile(r'[/\\:]')
@@ -424,7 +423,7 @@ def save_attachment(mlist, msg, dir, filter_html=True):
             ext = '.bin'
     path = None
     # We need a lock to calculate the next attachment number
-    with LockFile(os.path.join(fsdir, 'attachments.lock')):
+    with Lock(os.path.join(fsdir, 'attachments.lock')):
         # Now base the filename on what's in the attachment, uniquifying it if
         # necessary.
         if not filename or config.SCRUBBER_DONT_USE_ATTACHMENT_FILENAME:
diff --git a/Mailman/MTA/Postfix.py b/Mailman/MTA/Postfix.py
index 1712bb638..268d2f325 100644
--- a/Mailman/MTA/Postfix.py
+++ b/Mailman/MTA/Postfix.py
@@ -26,13 +26,13 @@ import time
 import errno
 import logging
 
+from locknix.lockfile import Lock
 from stat import *
 
 from Mailman import Utils
 from Mailman.MTA.Utils import makealiases
 from Mailman.configuration import config
 from Mailman.i18n import _
-from Mailman.lockfile import LockFile
 
 LOCKFILE = os.path.join(config.LOCK_DIR, 'creator')
 ALIASFILE = os.path.join(config.DATA_DIR, 'aliases')
@@ -338,7 +338,7 @@ def _do_remove(mlist, textfile):
 
 def remove(mlist, cgi=False):
     # Acquire the global list database lock
-    with LockFile(LOCKFILE):
+    with Lock(LOCKFILE):
         if config.USE_LMTP:
             _do_remove(mlist, TRPTFILE)
         else:
diff --git a/Mailman/bin/arch.py b/Mailman/bin/arch.py
index 09ca4d914..6227482ad 100644
--- a/Mailman/bin/arch.py
+++ b/Mailman/bin/arch.py
@@ -23,14 +23,15 @@ import errno
 import shutil
 import optparse
 
+from locknix.lockfile import Lock
+
 from Mailman import Errors
 from Mailman import Version
 from Mailman import i18n
 from Mailman.Archiver.HyperArch import HyperArchive
 from Mailman.Defaults import hours
-from Mailman.MailList import MailList
 from Mailman.configuration import config
-from Mailman.lockfile import LockFile
+from Mailman.initialize import initialize
 
 _ = i18n._
 __i18n_templates__ = True
@@ -103,62 +104,51 @@ def main():
         mbox = args[1]
 
     # Open the mailing list object
-    mlist = None
-    lock = None
-    try:
+    mlist = config.list_manager.get(listname)
+    if mlist is None:
+        parser.error(_('No such list: $listname'))
+    if mbox is None:
+        mbox = mlist.ArchiveFileName()
+
+    i18n.set_language(mlist.preferred_language)
+    # Lay claim to the archive's lock file.  This is so no other post can
+    # mess up the archive while we're processing it.  Try to pick a
+    # suitably long period of time for the lock lifetime even though we
+    # really don't know how long it will take.
+    #
+    # XXX processUnixMailbox() should refresh the lock.
+    lock_path = os.path.join(mlist.full_path, '.archiver.lck')
+    with Lock(lock_path, lifetime=int(hours(3))):
+        # Maybe wipe the old archives
+        if opts.wipe:
+            if mlist.scrub_nondigest:
+                # TK: save the attachments dir because they are not in mbox
+                saved = False
+                atchdir = os.path.join(mlist.archive_dir(), 'attachments')
+                savedir = os.path.join(mlist.archive_dir() + '.mbox',
+                                       'attachments')
+                try:
+                    os.rename(atchdir, savedir)
+                    saved = True
+                except OSError, e:
+                    if e.errno <> errno.ENOENT:
+                        raise
+            shutil.rmtree(mlist.archive_dir())
+            if mlist.scrub_nondigest and saved:
+                os.renames(savedir, atchdir)
         try:
-            mlist = MailList(listname)
-        except Errors.MMListError, e:
-            parser.print_help()
-            print >> sys.stderr, _('No such list: $listname\n$e')
+            fp = open(mbox)
+        except IOError, e:
+            if e.errno == errno.ENOENT:
+                print >> sys.stderr, _('Cannot open mbox file: $mbox')
+            else:
+                print >> sys.stderr, e
             sys.exit(1)
-        if mbox is None:
-            mbox = mlist.ArchiveFileName()
-
-        i18n.set_language(mlist.preferred_language)
-        # Lay claim to the archive's lock file.  This is so no other post can
-        # mess up the archive while we're processing it.  Try to pick a
-        # suitably long period of time for the lock lifetime even though we
-        # really don't know how long it will take.
-        #
-        # XXX processUnixMailbox() should refresh the lock.
-        with LockFile(os.path.join(mlist.full_path, '.archiver.lck'),
-                      lifetime=int(hours(3))):
-            # Maybe wipe the old archives
-            if opts.wipe:
-                if mlist.scrub_nondigest:
-                    # TK: save the attachments dir because they are not in mbox
-                    saved = False
-                    atchdir = os.path.join(mlist.archive_dir(), 'attachments')
-                    savedir = os.path.join(mlist.archive_dir() + '.mbox',
-                                           'attachments')
-                    try:
-                        os.rename(atchdir, savedir)
-                        saved = True
-                    except OSError, e:
-                        if e.errno <> errno.ENOENT:
-                            raise
-                shutil.rmtree(mlist.archive_dir())
-                if mlist.scrub_nondigest and saved:
-                    os.renames(savedir, atchdir)
-            try:
-                fp = open(mbox)
-            except IOError, e:
-                if e.errno == errno.ENOENT:
-                    print >> sys.stderr, _('Cannot open mbox file: $mbox')
-                else:
-                    print >> sys.stderr, e
-                sys.exit(1)
-
-            archiver = HyperArchive(mlist)
-            archiver.VERBOSE = opts.verbose
-            try:
-                archiver.processUnixMailbox(fp, opts.start, opts.end)
-            finally:
-                archiver.close()
-            fp.close()
 
-
-
-if __name__ == '__main__':
-    main()
+        archiver = HyperArchive(mlist)
+        archiver.VERBOSE = opts.verbose
+        try:
+            archiver.processUnixMailbox(fp, opts.start, opts.end)
+        finally:
+            archiver.close()
+        fp.close()
diff --git a/Mailman/bin/gate_news.py b/Mailman/bin/gate_news.py
index 6fc8139c6..9402504dc 100644
--- a/Mailman/bin/gate_news.py
+++ b/Mailman/bin/gate_news.py
@@ -24,15 +24,15 @@ import socket
 import logging
 import nntplib
 import optparse
-
 import email.Errors
+
 from email.Parser import Parser
+from locknix import lockfile
 
 from Mailman import MailList
 from Mailman import Message
 from Mailman import Utils
 from Mailman import Version
-from Mailman import lockfile
 from Mailman import loginit
 from Mailman.configuration import config
 from Mailman.i18n import _
@@ -233,12 +233,12 @@ def main():
     log = logging.getLogger('mailman.fromusenet')
 
     try:
-        with lockfile.LockFile(GATENEWS_LOCK_FILE,
-                               # It's okay to hijack this
-                               lifetime=LOCK_LIFETIME):
+        with lockfile.Lock(GATENEWS_LOCK_FILE,
+                           # It's okay to hijack this
+                           lifetime=LOCK_LIFETIME):
             process_lists(lock)
         clearcache()
-    except LockFile.TimeOutError:
+    except lockfile.TimeOutError:
         log.error('Could not acquire gate_news lock')
 
 
diff --git a/Mailman/bin/mailmanctl.py b/Mailman/bin/mailmanctl.py
index 07716029b..8b7eeb5d2 100644
--- a/Mailman/bin/mailmanctl.py
+++ b/Mailman/bin/mailmanctl.py
@@ -25,11 +25,12 @@ import socket
 import logging
 import optparse
 
+from locknix import lockfile
+
 from Mailman import Defaults
 from Mailman import Errors
 from Mailman import Utils
 from Mailman import Version
-from Mailman import lockfile
 from Mailman import loginit
 from Mailman.configuration import config
 from Mailman.i18n import _
@@ -197,7 +198,7 @@ def qrunner_state():
 def acquire_lock_1(force):
     # Be sure we can acquire the master qrunner lock.  If not, it means some
     # other master qrunner daemon is already going.
-    lock = lockfile.LockFile(config.LOCK_FILE, LOCK_LIFETIME)
+    lock = lockfile.Lock(config.LOCK_FILE, LOCK_LIFETIME)
     try:
         lock.lock(0.1)
         return lock
diff --git a/Mailman/bin/testall.py b/Mailman/bin/testall.py
index f6f263a31..9be591253 100644
--- a/Mailman/bin/testall.py
+++ b/Mailman/bin/testall.py
@@ -47,7 +47,7 @@ def v_callback(option, opt, value, parser):
     elif opt in ('-v', '--verbose'):
         delta = 1
     else:
-        delta = 0
+        raise AssertionError('Unexpected option: %s' % opt)
     dest = getattr(parser.values, option.dest)
     setattr(parser.values, option.dest, max(0, dest + delta))
 
@@ -217,7 +217,8 @@ def main():
         with open(cfg_out, 'a') as fp:
             print >> fp, 'SQLALCHEMY_ENGINE_URL = "%s"' % test_engine_url
 
-        initialize_2()
+        # With -vvv, turn on engine debugging.
+        initialize_2(opts.verbosity > 3)
 
         # Run the tests
         basedir = os.path.dirname(Mailman.__file__)
diff --git a/Mailman/bin/update.py b/Mailman/bin/update.py
index 93bb0021b..379a5a1b5 100644
--- a/Mailman/bin/update.py
+++ b/Mailman/bin/update.py
@@ -26,12 +26,13 @@ import cPickle
 import marshal
 import optparse
 
+from locknix.lockfile import TimeOutError
+
 from Mailman import MailList
 from Mailman import Message
 from Mailman import Pending
 from Mailman import Utils
 from Mailman import Version
-from Mailman.LockFile import TimeOutError
 from Mailman.MemberAdaptor import BYBOUNCE, ENABLED
 from Mailman.OldStyleMemberships import OldStyleMemberships
 from Mailman.Queue.Switchboard import Switchboard
diff --git a/Mailman/configuration.py b/Mailman/configuration.py
index e4d8ac715..eee9c8363 100644
--- a/Mailman/configuration.py
+++ b/Mailman/configuration.py
@@ -172,12 +172,15 @@ class Configuration(object):
         code = self.DEFAULT_SERVER_LANGUAGE
         self.languages.enable_language(code)
 
-    def add_domain(self, email_host, url_host):
-        """Add the definition of a virtual domain.
+    def add_domain(self, email_host, url_host=None):
+        """Add a virtual domain.
 
-        email_host is the right-hand side of the posting email address,
-        e.g. 'example.com' in 'mylist@example.com'.  url_host is the host name
-        part of the exposed web pages, e.g. 'www.example.com'."""
+        :param email_host: The host name for the email interface.
+        :param url_host: Optional host name for the web interface.  If not
+            given, the email host will be used.
+        """
+        if url_host is None:
+            url_host = email_host
         if email_host in self.domains:
             raise Errors.BadDomainSpecificationError(
                 'Duplicate email host: %s' % email_host)
diff --git a/Mailman/database/__init__.py b/Mailman/database/__init__.py
index e9c338952..acc74642f 100644
--- a/Mailman/database/__init__.py
+++ b/Mailman/database/__init__.py
@@ -25,10 +25,11 @@ __all__ = [
 
 import os
 
+from locknix.lockfile import Lock
 from elixir import objectstore
 from zope.interface import implements
 
-from Mailman.interfaces import IDatabase, IPending
+from Mailman.interfaces import IDatabase
 from Mailman.database.listmanager import ListManager
 from Mailman.database.usermanager import UserManager
 from Mailman.database.messagestore import MessageStore
@@ -55,14 +56,13 @@ class StockDatabase:
         self.pendings = None
         self.requests = None
 
-    def initialize(self):
+    def initialize(self, debug=None):
         from Mailman.configuration import config
         from Mailman.database import model
-        from Mailman.lockfile import LockFile
         # Serialize this so we don't get multiple processes trying to create
         # the database at the same time.
-        with LockFile(os.path.join(config.LOCK_DIR, 'dbcreate.lck')):
-            model.initialize()
+        with Lock(os.path.join(config.LOCK_DIR, 'dbcreate.lck')):
+            model.initialize(debug)
         self.list_manager = ListManager()
         self.user_manager = UserManager()
         self.message_store = MessageStore()
@@ -72,3 +72,7 @@ class StockDatabase:
 
     def flush(self):
         objectstore.flush()
+
+    def _reset(self):
+        model._reset()
+
diff --git a/Mailman/database/listmanager.py b/Mailman/database/listmanager.py
index 0f6d7a9aa..46f0aa859 100644
--- a/Mailman/database/listmanager.py
+++ b/Mailman/database/listmanager.py
@@ -26,7 +26,7 @@ from Mailman import Errors
 from Mailman.Utils import split_listname, fqdn_listname
 from Mailman.configuration import config
 from Mailman.database.model import MailingList, Pendings
-from Mailman.interfaces import IListManager, IPending
+from Mailman.interfaces import IListManager
 
 
 
@@ -63,5 +63,5 @@ class ListManager(object):
 
     @property
     def names(self):
-        for mlist in MailingList.select():
+        for mlist in MailingList.query.filter_by().all():
             yield fqdn_listname(mlist.list_name, mlist.host_name)
diff --git a/Mailman/database/messagestore.py b/Mailman/database/messagestore.py
index bbaa6976b..e0e6cd9f1 100644
--- a/Mailman/database/messagestore.py
+++ b/Mailman/database/messagestore.py
@@ -97,11 +97,11 @@ class MessageStore:
             return pickle.load(fp)
 
     def get_messages_by_message_id(self, message_id):
-        for msgrow in Message.select_by(message_id=message_id):
+        for msgrow in Message.query.filter_by(message_id=message_id):
             yield self._msgobj(msgrow)
 
     def get_messages_by_hash(self, hash):
-        for msgrow in Message.select_by(hash=hash):
+        for msgrow in Message.query.filter_by(hash=hash):
             yield self._msgobj(msgrow)
 
     def _getmsg(self, global_id):
@@ -110,15 +110,15 @@ class MessageStore:
             seqno = int(seqno)
         except ValueError:
             return None
-        msgrows = Message.select_by(id=seqno)
-        if not msgrows:
+        messages = Message.query.filter_by(id=seqno)
+        if messages.count() == 0:
             return None
-        assert len(msgrows) == 1, 'Multiple id matches'
-        if msgrows[0].hash <> hash:
+        assert messages.count() == 1, 'Multiple id matches'
+        if messages[0].hash <> hash:
             # The client lied about which message they wanted.  They gave a
             # valid sequence number, but the hash did not match.
             return None
-        return msgrows[0]
+        return messages[0]
 
     def get_message(self, global_id):
         msgrow = self._getmsg(global_id)
@@ -126,7 +126,7 @@ class MessageStore:
 
     @property
     def messages(self):
-        for msgrow in Message.select():
+        for msgrow in Message.query.filter_by().all():
             yield self._msgobj(msgrow)
 
     def delete_message(self, global_id):
diff --git a/Mailman/database/model/__init__.py b/Mailman/database/model/__init__.py
index ed91fe018..86f79a84b 100644
--- a/Mailman/database/model/__init__.py
+++ b/Mailman/database/model/__init__.py
@@ -36,11 +36,15 @@ from urlparse import urlparse
 
 import Mailman.Version
 
-elixir.delay_setup = True
-
 from Mailman import constants
 from Mailman.Errors import SchemaVersionMismatchError
 from Mailman.configuration import config
+
+# This /must/ be set before any Elixir classes are defined (i.e. imported).
+# This tells Elixir to use the short table names (i.e. the class name) instead
+# of a mangled full class path.
+elixir.options_defaults['shortnames'] = True
+
 from Mailman.database.model.address import Address
 from Mailman.database.model.language import Language
 from Mailman.database.model.mailinglist import MailingList
@@ -54,7 +58,7 @@ from Mailman.database.model.version import Version
 
 
 
-def initialize():
+def initialize(debug):
     # Calculate the engine url
     url = Template(config.SQLALCHEMY_ENGINE_URL).safe_substitute(config.paths)
     # XXX By design of SQLite, database file creation does not honor
@@ -72,16 +76,17 @@ def initialize():
     # could have chmod'd the file after the fact, but half dozen and all...
     touch(url)
     engine = create_engine(url)
-    engine.echo = config.SQLALCHEMY_ECHO
-    elixir.metadata.connect(engine)
+    engine.echo = (config.SQLALCHEMY_ECHO if debug is None else debug)
+    elixir.metadata.bind = engine
     elixir.setup_all()
+    elixir.create_all()
     # Validate schema version.
     v = Version.get_by(component='schema')
     if not v:
         # Database has not yet been initialized
         v = Version(component='schema',
                     version=Mailman.Version.DATABASE_SCHEMA_VERSION)
-        elixir.objectstore.flush()
+        elixir.session.flush()
     elif v.version <> Mailman.Version.DATABASE_SCHEMA_VERSION:
         # XXX Update schema
         raise SchemaVersionMismatchError(v.version)
@@ -96,3 +101,9 @@ def touch(url):
     # Ignore errors
     if fd > 0:
         os.close(fd)
+
+
+def _reset():
+    for entity in elixir.entities:
+        for row in entity.query.filter_by().all():
+            row.delete()
diff --git a/Mailman/database/model/address.py b/Mailman/database/model/address.py
index 391004413..3ba3c3dbf 100644
--- a/Mailman/database/model/address.py
+++ b/Mailman/database/model/address.py
@@ -32,16 +32,14 @@ USER_KIND       = 'Mailman.database.model.user.User'
 class Address(Entity):
     implements(IAddress)
 
-    has_field('address',        Unicode)
-    has_field('_original',      Unicode)
-    has_field('real_name',      Unicode)
-    has_field('verified_on',   DateTime)
-    has_field('registered_on',  DateTime)
-    # Relationships
-    belongs_to('user',          of_kind=USER_KIND)
-    belongs_to('preferences',   of_kind=PREFERENCE_KIND)
-    # Options
-    using_options(shortnames=True)
+    address = Field(Unicode)
+    _original = Field(Unicode)
+    real_name = Field(Unicode)
+    verified_on = Field(DateTime)
+    registered_on = Field(DateTime)
+
+    user = ManyToOne(USER_KIND)
+    preferences = ManyToOne(PREFERENCE_KIND)
 
     def __init__(self, address, real_name):
         super(Address, self).__init__()
diff --git a/Mailman/database/model/language.py b/Mailman/database/model/language.py
index e065d5bad..ffdbd2cba 100644
--- a/Mailman/database/model/language.py
+++ b/Mailman/database/model/language.py
@@ -16,9 +16,13 @@
 # USA.
 
 from elixir import *
+from zope.interface import implements
 
+from Mailman.interfaces import ILanguage
 
+
+
 class Language(Entity):
-    has_field('code',   Unicode)
-    # Options
-    using_options(shortnames=True)
+    implements(ILanguage)
+
+    code = Field(Unicode)
diff --git a/Mailman/database/model/mailinglist.py b/Mailman/database/model/mailinglist.py
index fff5cbb9c..4057c2161 100644
--- a/Mailman/database/model/mailinglist.py
+++ b/Mailman/database/model/mailinglist.py
@@ -35,131 +35,129 @@ class MailingList(Entity):
     implements(IMailingList)
 
     # List identity
-    has_field('list_name',                                  Unicode),
-    has_field('host_name',                                  Unicode),
+    list_name = Field(Unicode)
+    host_name = Field(Unicode)
     # Attributes not directly modifiable via the web u/i
-    has_field('created_at',                                 DateTime),
-    has_field('web_page_url',                               Unicode),
-    has_field('admin_member_chunksize',                     Integer),
-    has_field('hold_and_cmd_autoresponses',                 PickleType),
+    created_at = Field(DateTime)
+    web_page_url = Field(Unicode)
+    admin_member_chunksize = Field(Integer)
+    hold_and_cmd_autoresponses = Field(PickleType)
     # Attributes which are directly modifiable via the web u/i.  The more
     # complicated attributes are currently stored as pickles, though that
     # will change as the schema and implementation is developed.
-    has_field('next_request_id',                            Integer),
-    has_field('next_digest_number',                         Integer),
-    has_field('admin_responses',                            PickleType),
-    has_field('postings_responses',                         PickleType),
-    has_field('request_responses',                          PickleType),
-    has_field('digest_last_sent_at',                        Float),
-    has_field('one_last_digest',                            PickleType),
-    has_field('volume',                                     Integer),
-    has_field('last_post_time',                             DateTime),
+    next_request_id = Field(Integer)
+    next_digest_number = Field(Integer)
+    admin_responses = Field(PickleType)
+    postings_responses = Field(PickleType)
+    request_responses = Field(PickleType)
+    digest_last_sent_at = Field(Float)
+    one_last_digest = Field(PickleType)
+    volume = Field(Integer)
+    last_post_time = Field(DateTime)
     # Attributes which are directly modifiable via the web u/i.  The more
     # complicated attributes are currently stored as pickles, though that
     # will change as the schema and implementation is developed.
-    has_field('accept_these_nonmembers',                    PickleType),
-    has_field('acceptable_aliases',                         PickleType),
-    has_field('admin_immed_notify',                         Boolean),
-    has_field('admin_notify_mchanges',                      Boolean),
-    has_field('administrivia',                              Boolean),
-    has_field('advertised',                                 Boolean),
-    has_field('anonymous_list',                             Boolean),
-    has_field('archive',                                    Boolean),
-    has_field('archive_private',                            Boolean),
-    has_field('archive_volume_frequency',                   Integer),
-    has_field('autorespond_admin',                          Boolean),
-    has_field('autorespond_postings',                       Boolean),
-    has_field('autorespond_requests',                       Integer),
-    has_field('autoresponse_admin_text',                    Unicode),
-    has_field('autoresponse_graceperiod',                   TimeDeltaType),
-    has_field('autoresponse_postings_text',                 Unicode),
-    has_field('autoresponse_request_text',                  Unicode),
-    has_field('ban_list',                                   PickleType),
-    has_field('bounce_info_stale_after',                    TimeDeltaType),
-    has_field('bounce_matching_headers',                    Unicode),
-    has_field('bounce_notify_owner_on_disable',             Boolean),
-    has_field('bounce_notify_owner_on_removal',             Boolean),
-    has_field('bounce_processing',                          Boolean),
-    has_field('bounce_score_threshold',                     Integer),
-    has_field('bounce_unrecognized_goes_to_list_owner',     Boolean),
-    has_field('bounce_you_are_disabled_warnings',           Integer),
-    has_field('bounce_you_are_disabled_warnings_interval',  TimeDeltaType),
-    has_field('collapse_alternatives',                      Boolean),
-    has_field('convert_html_to_plaintext',                  Boolean),
-    has_field('default_member_moderation',                  Boolean),
-    has_field('description',                                Unicode),
-    has_field('digest_footer',                              Unicode),
-    has_field('digest_header',                              Unicode),
-    has_field('digest_is_default',                          Boolean),
-    has_field('digest_send_periodic',                       Boolean),
-    has_field('digest_size_threshold',                      Integer),
-    has_field('digest_volume_frequency',                    Integer),
-    has_field('digestable',                                 Boolean),
-    has_field('discard_these_nonmembers',                   PickleType),
-    has_field('emergency',                                  Boolean),
-    has_field('encode_ascii_prefixes',                      Boolean),
-    has_field('filter_action',                              Integer),
-    has_field('filter_content',                             Boolean),
-    has_field('filter_filename_extensions',                 PickleType),
-    has_field('filter_mime_types',                          PickleType),
-    has_field('first_strip_reply_to',                       Boolean),
-    has_field('forward_auto_discards',                      Boolean),
-    has_field('gateway_to_mail',                            Boolean),
-    has_field('gateway_to_news',                            Boolean),
-    has_field('generic_nonmember_action',                   Integer),
-    has_field('goodbye_msg',                                Unicode),
-    has_field('header_filter_rules',                        PickleType),
-    has_field('hold_these_nonmembers',                      PickleType),
-    has_field('include_list_post_header',                   Boolean),
-    has_field('include_rfc2369_headers',                    Boolean),
-    has_field('info',                                       Unicode),
-    has_field('linked_newsgroup',                           Unicode),
-    has_field('max_days_to_hold',                           Integer),
-    has_field('max_message_size',                           Integer),
-    has_field('max_num_recipients',                         Integer),
-    has_field('member_moderation_action',                   Boolean),
-    has_field('member_moderation_notice',                   Unicode),
-    has_field('mime_is_default_digest',                     Boolean),
-    has_field('moderator_password',                         Unicode),
-    has_field('msg_footer',                                 Unicode),
-    has_field('msg_header',                                 Unicode),
-    has_field('new_member_options',                         Integer),
-    has_field('news_moderation',                            EnumType),
-    has_field('news_prefix_subject_too',                    Boolean),
-    has_field('nntp_host',                                  Unicode),
-    has_field('nondigestable',                              Boolean),
-    has_field('nonmember_rejection_notice',                 Unicode),
-    has_field('obscure_addresses',                          Boolean),
-    has_field('pass_filename_extensions',                   PickleType),
-    has_field('pass_mime_types',                            PickleType),
-    has_field('personalize',                                EnumType),
-    has_field('post_id',                                    Integer),
-    has_field('preferred_language',                         Unicode),
-    has_field('private_roster',                             Boolean),
-    has_field('real_name',                                  Unicode),
-    has_field('reject_these_nonmembers',                    PickleType),
-    has_field('reply_goes_to_list',                         EnumType),
-    has_field('reply_to_address',                           Unicode),
-    has_field('require_explicit_destination',               Boolean),
-    has_field('respond_to_post_requests',                   Boolean),
-    has_field('scrub_nondigest',                            Boolean),
-    has_field('send_goodbye_msg',                           Boolean),
-    has_field('send_reminders',                             Boolean),
-    has_field('send_welcome_msg',                           Boolean),
-    has_field('subject_prefix',                             Unicode),
-    has_field('subscribe_auto_approval',                    PickleType),
-    has_field('subscribe_policy',                           Integer),
-    has_field('topics',                                     PickleType),
-    has_field('topics_bodylines_limit',                     Integer),
-    has_field('topics_enabled',                             Boolean),
-    has_field('unsubscribe_policy',                         Integer),
-    has_field('welcome_msg',                                Unicode),
+    accept_these_nonmembers = Field(PickleType)
+    acceptable_aliases = Field(PickleType)
+    admin_immed_notify = Field(Boolean)
+    admin_notify_mchanges = Field(Boolean)
+    administrivia = Field(Boolean)
+    advertised = Field(Boolean)
+    anonymous_list = Field(Boolean)
+    archive = Field(Boolean)
+    archive_private = Field(Boolean)
+    archive_volume_frequency = Field(Integer)
+    autorespond_admin = Field(Boolean)
+    autorespond_postings = Field(Boolean)
+    autorespond_requests = Field(Integer)
+    autoresponse_admin_text = Field(Unicode)
+    autoresponse_graceperiod = Field(TimeDeltaType)
+    autoresponse_postings_text = Field(Unicode)
+    autoresponse_request_text = Field(Unicode)
+    ban_list = Field(PickleType)
+    bounce_info_stale_after = Field(TimeDeltaType)
+    bounce_matching_headers = Field(Unicode)
+    bounce_notify_owner_on_disable = Field(Boolean)
+    bounce_notify_owner_on_removal = Field(Boolean)
+    bounce_processing = Field(Boolean)
+    bounce_score_threshold = Field(Integer)
+    bounce_unrecognized_goes_to_list_owner = Field(Boolean)
+    bounce_you_are_disabled_warnings = Field(Integer)
+    bounce_you_are_disabled_warnings_interval = Field(TimeDeltaType)
+    collapse_alternatives = Field(Boolean)
+    convert_html_to_plaintext = Field(Boolean)
+    default_member_moderation = Field(Boolean)
+    description = Field(Unicode)
+    digest_footer = Field(Unicode)
+    digest_header = Field(Unicode)
+    digest_is_default = Field(Boolean)
+    digest_send_periodic = Field(Boolean)
+    digest_size_threshold = Field(Integer)
+    digest_volume_frequency = Field(Integer)
+    digestable = Field(Boolean)
+    discard_these_nonmembers = Field(PickleType)
+    emergency = Field(Boolean)
+    encode_ascii_prefixes = Field(Boolean)
+    filter_action = Field(Integer)
+    filter_content = Field(Boolean)
+    filter_filename_extensions = Field(PickleType)
+    filter_mime_types = Field(PickleType)
+    first_strip_reply_to = Field(Boolean)
+    forward_auto_discards = Field(Boolean)
+    gateway_to_mail = Field(Boolean)
+    gateway_to_news = Field(Boolean)
+    generic_nonmember_action = Field(Integer)
+    goodbye_msg = Field(Unicode)
+    header_filter_rules = Field(PickleType)
+    hold_these_nonmembers = Field(PickleType)
+    include_list_post_header = Field(Boolean)
+    include_rfc2369_headers = Field(Boolean)
+    info = Field(Unicode)
+    linked_newsgroup = Field(Unicode)
+    max_days_to_hold = Field(Integer)
+    max_message_size = Field(Integer)
+    max_num_recipients = Field(Integer)
+    member_moderation_action = Field(Boolean)
+    member_moderation_notice = Field(Unicode)
+    mime_is_default_digest = Field(Boolean)
+    moderator_password = Field(Unicode)
+    msg_footer = Field(Unicode)
+    msg_header = Field(Unicode)
+    new_member_options = Field(Integer)
+    news_moderation = Field(EnumType)
+    news_prefix_subject_too = Field(Boolean)
+    nntp_host = Field(Unicode)
+    nondigestable = Field(Boolean)
+    nonmember_rejection_notice = Field(Unicode)
+    obscure_addresses = Field(Boolean)
+    pass_filename_extensions = Field(PickleType)
+    pass_mime_types = Field(PickleType)
+    personalize = Field(EnumType)
+    post_id = Field(Integer)
+    preferred_language = Field(Unicode)
+    private_roster = Field(Boolean)
+    real_name = Field(Unicode)
+    reject_these_nonmembers = Field(PickleType)
+    reply_goes_to_list = Field(EnumType)
+    reply_to_address = Field(Unicode)
+    require_explicit_destination = Field(Boolean)
+    respond_to_post_requests = Field(Boolean)
+    scrub_nondigest = Field(Boolean)
+    send_goodbye_msg = Field(Boolean)
+    send_reminders = Field(Boolean)
+    send_welcome_msg = Field(Boolean)
+    subject_prefix = Field(Unicode)
+    subscribe_auto_approval = Field(PickleType)
+    subscribe_policy = Field(Integer)
+    topics = Field(PickleType)
+    topics_bodylines_limit = Field(Integer)
+    topics_enabled = Field(Boolean)
+    unsubscribe_policy = Field(Integer)
+    welcome_msg = Field(Unicode)
     # Relationships
 ##     has_and_belongs_to_many(
 ##         'available_languages',
 ##         of_kind='Mailman.database.model.languages.Language')
-    # Options
-    using_options(shortnames=True)
 
     def __init__(self, fqdn_listname):
         super(MailingList, self).__init__()
diff --git a/Mailman/database/model/member.py b/Mailman/database/model/member.py
index 1dc942323..4f353a06c 100644
--- a/Mailman/database/model/member.py
+++ b/Mailman/database/model/member.py
@@ -32,13 +32,11 @@ PREFERENCE_KIND = 'Mailman.database.model.preferences.Preferences'
 class Member(Entity):
     implements(IMember)
 
-    has_field('role',           EnumType)
-    has_field('mailing_list',   Unicode)
+    role = Field(EnumType)
+    mailing_list = Field(Unicode)
     # Relationships
-    belongs_to('address',       of_kind=ADDRESS_KIND)
-    belongs_to('preferences',   of_kind=PREFERENCE_KIND)
-    # Options
-    using_options(shortnames=True)
+    address = ManyToOne(ADDRESS_KIND)
+    preferences = ManyToOne(PREFERENCE_KIND)
 
     def __repr__(self):
         return '<Member: %s on %s as %s>' % (
diff --git a/Mailman/database/model/message.py b/Mailman/database/model/message.py
index df8371c6a..eb4b4616d 100644
--- a/Mailman/database/model/message.py
+++ b/Mailman/database/model/message.py
@@ -18,13 +18,15 @@
 from elixir import *
 from zope.interface import implements
 
+from Mailman.interfaces import IMessage
+
 
 
 class Message(Entity):
     """A message in the message store."""
 
-    has_field('hash',       Unicode)
-    has_field('path',       Unicode)
-    has_field('message_id', Unicode)
+    implements(IMessage)
 
-    using_options(shortnames=True)
+    hash = Field(Unicode)
+    path = Field(Unicode)
+    message_id = Field(Unicode)
diff --git a/Mailman/database/model/pending.py b/Mailman/database/model/pending.py
index ae2ad3d60..75bb59d3c 100644
--- a/Mailman/database/model/pending.py
+++ b/Mailman/database/model/pending.py
@@ -27,30 +27,30 @@ from zope.interface import implements
 from zope.interface.verify import verifyObject
 
 from Mailman.configuration import config
-from Mailman.interfaces import IPending, IPendable
+from Mailman.interfaces import (
+    IPendings, IPendable, IPendedKeyValue, IPended)
 
-PEND_KIND = 'Mailman.database.model.pending.Pending'
+PEND_KIND = 'Mailman.database.model.pending.Pended'
 
 
 
 class PendedKeyValue(Entity):
     """A pended key/value pair, tied to a token."""
 
-    has_field('key',        Unicode)
-    has_field('value',      Unicode)
-    # Relationships
-    belongs_to('pended',    of_kind=PEND_KIND)
-    # Options
-    using_options(shortnames=True)
+    implements(IPendedKeyValue)
 
+    key = Field(Unicode)
+    value = Field(Unicode)
+    pended = ManyToOne(PEND_KIND)
 
-class Pending(Entity):
+
+class Pended(Entity):
     """A pended event, tied to a token."""
 
-    has_field('token',              Unicode)
-    has_field('expiration_date',    DateTime)
-    # Options
-    using_options(shortnames=True)
+    implements(IPended)
+
+    token = Field(Unicode)
+    expiration_date = Field(DateTime)
 
 
 
@@ -62,7 +62,7 @@ class UnpendedPendable(dict):
 class Pendings(object):
     """Implementation of the IPending interface."""
 
-    implements(IPending)
+    implements(IPendings)
 
     def add(self, pendable, lifetime=None):
         verifyObject(IPendable, pendable)
@@ -75,17 +75,19 @@ class Pendings(object):
         # clock values basically help obscure the random number generator, as
         # does the hash calculation.  The integral parts of the time values
         # are discarded because they're the most predictable bits.
-        while True:
+        for attempts in range(3):
             now = time.time()
             x = random.random() + now % 1.0 + time.clock() % 1.0
             # Use sha1 because it produces shorter strings.
             token = hashlib.sha1(repr(x)).hexdigest()
             # In practice, we'll never get a duplicate, but we'll be anal
             # about checking anyway.
-            if not Pending.select_by(token=token):
+            if Pended.query.filter_by(token=token).count() == 0:
                 break
+        else:
+            raise AssertionError('Could not find a valid pendings token')
         # Create the record, and then the individual key/value pairs.
-        pending = Pending(
+        pending = Pended(
             token=token,
             expiration_date=datetime.datetime.now() + lifetime)
         for key, value in pendable.items():
@@ -93,17 +95,18 @@ class Pendings(object):
         return token
 
     def confirm(self, token, expunge=True):
-        pendings = Pending.select_by(token=token)
-        assert 0 <= len(pendings) <= 1, 'Unexpected token search results'
-        if len(pendings) == 0:
+        pendings = Pended.query.filter_by(token=token)
+        if pendings.count() == 0:
             return None
+        assert pendings.count() == 1, (
+            'Unexpected token count: %d' % pendings.count())
         pending = pendings[0]
         pendable = UnpendedPendable()
         # Find all PendedKeyValue entries that are associated with the pending
         # object's ID.
-        q = PendedKeyValue.filter(
-            PendedKeyValue.c.pended_id == Pending.c.id).filter(
-            Pending.c.id == pending.id)
+        q = PendedKeyValue.query.filter(
+            PendedKeyValue.c.pended_id == Pended.c.id).filter(
+            Pended.c.id == pending.id)
         for keyvalue in q.all():
             pendable[keyvalue.key] = keyvalue.value
             if expunge:
@@ -114,13 +117,13 @@ class Pendings(object):
 
     def evict(self):
         now = datetime.datetime.now()
-        for pending in Pending.select():
+        for pending in Pended.query.filter_by().all():
             if pending.expiration_date < now:
                 # Find all PendedKeyValue entries that are associated with the
                 # pending object's ID.
-                q = PendedKeyValue.filter(
-                    PendedKeyValue.c.pended_id == Pending.c.id).filter(
-                    Pending.c.id == pending.id)
+                q = PendedKeyValue.query.filter(
+                    PendedKeyValue.c.pended_id == Pended.c.id).filter(
+                    Pended.c.id == pending.id)
                 for keyvalue in q:
                     keyvalue.delete()
                 pending.delete()
diff --git a/Mailman/database/model/preferences.py b/Mailman/database/model/preferences.py
index 07d4d84e2..8cbb77e6a 100644
--- a/Mailman/database/model/preferences.py
+++ b/Mailman/database/model/preferences.py
@@ -31,15 +31,13 @@ USER_KIND       = 'Mailman.database.model.user.User'
 class Preferences(Entity):
     implements(IPreferences)
 
-    has_field('acknowledge_posts',      Boolean)
-    has_field('hide_address',           Boolean)
-    has_field('preferred_language',     Unicode)
-    has_field('receive_list_copy',      Boolean)
-    has_field('receive_own_postings',   Boolean)
-    has_field('delivery_mode',          EnumType)
-    has_field('delivery_status',        EnumType)
-    # Options
-    using_options(shortnames=True)
+    acknowledge_posts = Field(Boolean)
+    hide_address = Field(Boolean)
+    preferred_language = Field(Unicode)
+    receive_list_copy = Field(Boolean)
+    receive_own_postings = Field(Boolean)
+    delivery_mode = Field(EnumType)
+    delivery_status = Field(EnumType)
 
     def __repr__(self):
         return '<Preferences object at %#x>' % id(self)
diff --git a/Mailman/database/model/requests.py b/Mailman/database/model/requests.py
index ea917c2b9..037483c1a 100644
--- a/Mailman/database/model/requests.py
+++ b/Mailman/database/model/requests.py
@@ -49,23 +49,21 @@ class ListRequests:
 
     @property
     def count(self):
-        results = _Request.select_by(mailing_list=self.mailing_list)
-        return len(results)
+        return _Request.query.filter_by(mailing_list=self.mailing_list).count()
 
     def count_of(self, request_type):
-        results = _Request.select_by(mailing_list=self.mailing_list,
-                                     type=request_type)
-        return len(results)
+        return _Request.query.filter_by(mailing_list=self.mailing_list,
+                                        type=request_type).count()
 
     @property
     def held_requests(self):
-        results = _Request.select_by(mailing_list=self.mailing_list)
+        results = _Request.query.filter_by(mailing_list=self.mailing_list)
         for request in results:
             yield request
 
     def of_type(self, request_type):
-        results = _Request.select_by(mailing_list=self.mailing_list,
-                                     type=request_type)
+        results = _Request.query.filter_by(mailing_list=self.mailing_list,
+                                           type=request_type)
         for request in results:
             yield request
 
@@ -132,10 +130,8 @@ class Requests:
 class _Request(Entity):
     """Table for mailing list hold requests."""
 
-    has_field('key',            Unicode)
-    has_field('type',           EnumType)
-    has_field('data_hash',      Unicode)
+    key = Field(Unicode)
+    type = Field(EnumType)
+    data_hash = Field(Unicode)
     # Relationships
-    belongs_to('mailing_list',  of_kind=MAILINGLIST_KIND)
-    # Options
-    using_options(shortnames=True)
+    mailing_list = ManyToOne(MAILINGLIST_KIND)
diff --git a/Mailman/database/model/roster.py b/Mailman/database/model/roster.py
index e59bc8b17..c8fa86d58 100644
--- a/Mailman/database/model/roster.py
+++ b/Mailman/database/model/roster.py
@@ -49,8 +49,9 @@ class AbstractRoster(object):
 
     @property
     def members(self):
-        for member in Member.select_by(mailing_list=self._mlist.fqdn_listname,
-                                       role=self.role):
+        for member in Member.query.filter_by(
+                mailing_list=self._mlist.fqdn_listname,
+                role=self.role):
             yield member
 
     @property
@@ -72,18 +73,18 @@ class AbstractRoster(object):
             yield member.address
 
     def get_member(self, address):
-        results = Member.select(
+        results = Member.query.filter(
             and_(Member.c.mailing_list == self._mlist.fqdn_listname,
                  Member.c.role == self.role,
                  Address.c.address == address,
                  Member.c.address_id == Address.c.id))
-        if len(results) == 0:
+        if results.count() == 0:
             return None
-        elif len(results) == 1:
+        elif results.count() == 1:
             return results[0]
         else:
-            assert len(results) <= 1, (
-                'Too many matching member results: %s' % results)
+            raise AssertionError('Too many matching member results: %s' %
+                                 results.count())
 
 
 
@@ -120,7 +121,7 @@ class AdministratorRoster(AbstractRoster):
     def members(self):
         # Administrators are defined as the union of the owners and the
         # moderators.
-        members = Member.select(
+        members = Member.query.filter(
             and_(Member.c.mailing_list == self._mlist.fqdn_listname,
                  or_(Member.c.role == MemberRole.owner,
                      Member.c.role == MemberRole.moderator)))
@@ -128,18 +129,18 @@ class AdministratorRoster(AbstractRoster):
             yield member
 
     def get_member(self, address):
-        results = Member.select(
+        results = Member.query.filter(
             and_(Member.c.mailing_list == self._mlist.fqdn_listname,
                  or_(Member.c.role == MemberRole.moderator,
                      Member.c.role == MemberRole.owner),
                  Address.c.address == address,
                  Member.c.address_id == Address.c.id))
-        if len(results) == 0:
+        if results.count() == 0:
             return None
-        elif len(results) == 1:
+        elif results.count() == 1:
             return results[0]
         else:
-            assert len(results) <= 1, (
+            raise AssertionError(
                 'Too many matching member results: %s' % results)
 
 
@@ -154,8 +155,9 @@ class RegularMemberRoster(AbstractRoster):
         # Query for all the Members which have a role of MemberRole.member and
         # are subscribed to this mailing list.  Then return only those members
         # that have a regular delivery mode.
-        for member in Member.select_by(mailing_list=self._mlist.fqdn_listname,
-                                       role=MemberRole.member):
+        for member in Member.query.filter_by(
+                mailing_list=self._mlist.fqdn_listname,
+                role=MemberRole.member):
             if member.delivery_mode == DeliveryMode.regular:
                 yield member
 
@@ -179,8 +181,9 @@ class DigestMemberRoster(AbstractRoster):
         # Query for all the Members which have a role of MemberRole.member and
         # are subscribed to this mailing list.  Then return only those members
         # that have one of the digest delivery modes.
-        for member in Member.select_by(mailing_list=self._mlist.fqdn_listname,
-                                       role=MemberRole.member):
+        for member in Member.query.filter_by(
+                mailing_list=self._mlist.fqdn_listname,
+                role=MemberRole.member):
             if member.delivery_mode in _digest_modes:
                 yield member
 
@@ -193,5 +196,6 @@ class Subscribers(AbstractRoster):
 
     @property
     def members(self):
-        for member in Member.select_by(mailing_list=self._mlist.fqdn_listname):
+        for member in Member.query.filter_by(
+                mailing_list=self._mlist.fqdn_listname):
             yield member
diff --git a/Mailman/database/model/user.py b/Mailman/database/model/user.py
index 683ec0f90..895beef9f 100644
--- a/Mailman/database/model/user.py
+++ b/Mailman/database/model/user.py
@@ -32,13 +32,11 @@ PREFERENCE_KIND = 'Mailman.database.model.preferences.Preferences'
 class User(Entity):
     implements(IUser)
 
-    has_field('real_name',  Unicode)
-    has_field('password',   Unicode)
-    # Relationships
-    has_many('addresses',       of_kind=ADDRESS_KIND)
-    belongs_to('preferences',   of_kind=PREFERENCE_KIND)
-    # Options
-    using_options(shortnames=True)
+    real_name = Field(Unicode)
+    password = Field(Unicode)
+
+    addresses = OneToMany(ADDRESS_KIND)
+    preferences = ManyToOne(PREFERENCE_KIND)
 
     def __repr__(self):
         return '<User "%s" at %#x>' % (self.real_name, id(self))
@@ -47,13 +45,11 @@ class User(Entity):
         if address.user is not None:
             raise Errors.AddressAlreadyLinkedError(address)
         address.user = self
-        self.addresses.append(address)
 
     def unlink(self, address):
         if address.user is None:
             raise Errors.AddressNotLinkedError(address)
         address.user = None
-        self.addresses.remove(address)
 
     def controls(self, address):
         found = Address.get_by(address=address)
diff --git a/Mailman/database/model/version.py b/Mailman/database/model/version.py
index 7b12778ce..dbbf5b8c1 100644
--- a/Mailman/database/model/version.py
+++ b/Mailman/database/model/version.py
@@ -19,7 +19,5 @@ from elixir import *
 
 
 class Version(Entity):
-    has_field('component',  Unicode)
-    has_field('version',    Integer)
-    # Options
-    using_options(shortnames=True)
+    component = Field(Unicode)
+    version = Field(Integer)
diff --git a/Mailman/database/usermanager.py b/Mailman/database/usermanager.py
index 1958080fd..6bc2ed53d 100644
--- a/Mailman/database/usermanager.py
+++ b/Mailman/database/usermanager.py
@@ -36,7 +36,7 @@ class UserManager(object):
 
     def create_user(self, address=None, real_name=None):
         user = User()
-        user.real_name = (real_name if real_name is not None else '')
+        user.real_name = ('' if real_name is None else real_name)
         if address:
             addrobj = Address(address, user.real_name)
             addrobj.preferences = Preferences()
@@ -49,19 +49,28 @@ class UserManager(object):
 
     @property
     def users(self):
-        for user in User.select():
+        for user in User.query.filter_by().all():
             yield user
 
     def get_user(self, address):
-        found = Address.get_by(address=address.lower())
-        return found and found.user
+        addresses = Address.query.filter_by(address=address.lower())
+        if addresses.count() == 0:
+            return None
+        elif addresses.count() == 1:
+            return addresses[0].user
+        else:
+            raise AssertionError('Unexpected query count')
 
     def create_address(self, address, real_name=None):
-        found = Address.get_by(address=address.lower())
-        if found:
+        addresses = Address.query.filter_by(address=address.lower())
+        if addresses.count() == 1:
+            found = addresses[0]
             raise Errors.ExistingAddressError(found.original_address)
+        assert addresses.count() == 0, 'Unexpected results'
         if real_name is None:
             real_name = ''
+        # It's okay not to lower case the 'address' argument because the
+        # constructor will do the right thing.
         address = Address(address, real_name)
         address.preferences = Preferences()
         return address
@@ -74,9 +83,15 @@ class UserManager(object):
         address.delete()
 
     def get_address(self, address):
-        return Address.get_by(address=address.lower())
+        addresses = Address.query.filter_by(address=address.lower())
+        if addresses.count() == 0:
+            return None
+        elif addresses.count() == 1:
+            return addresses[0]
+        else:
+            raise AssertionError('Unexpected query count')
 
     @property
     def addresses(self):
-        for address in Address.select():
+        for address in Address.query.filter_by().all():
             yield address
diff --git a/Mailman/docs/addresses.txt b/Mailman/docs/addresses.txt
index 4d4157f83..4dd8b44ad 100644
--- a/Mailman/docs/addresses.txt
+++ b/Mailman/docs/addresses.txt
@@ -68,6 +68,8 @@ You can create email addresses that are linked to users by using a different
 interface.
 
     >>> user_1 = usermgr.create_user('cperson@example.com', 'Claire Person')
+    >>> sorted(address.address for address in user_1.addresses)
+    ['cperson@example.com']
     >>> flush()
     >>> sorted(address.address for address in usermgr.addresses)
     ['aperson@example.com', 'bperson@example.com', 'cperson@example.com']
@@ -87,7 +89,7 @@ And now you can find the associated user.
 Deleting addresses
 ------------------
 
-You can remove an unlinked address from the usre manager.
+You can remove an unlinked address from the user manager.
 
     >>> usermgr.delete_address(address_1)
     >>> flush()
diff --git a/Mailman/docs/pending.txt b/Mailman/docs/pending.txt
index de6326219..d93da5283 100644
--- a/Mailman/docs/pending.txt
+++ b/Mailman/docs/pending.txt
@@ -8,20 +8,21 @@ This is not where messages held for administrator approval are kept.
 
     >>> from Mailman.configuration import config
     >>> from Mailman.database import flush
-    >>> from Mailman.interfaces import IPendable, IPending
     >>> from zope.interface import implements
     >>> from zope.interface.verify import verifyObject
 
 In order to pend an event, you first need a pending database, which is
 available by adapting the list manager.
 
+    >>> from Mailman.interfaces import IPendings
     >>> pendingdb = config.db.pendings
-    >>> verifyObject(IPending, pendingdb)
+    >>> verifyObject(IPendings, pendingdb)
     True
 
 The pending database can add any IPendable to the database, returning a token
 that can be used in urls and such.
 
+    >>> from Mailman.interfaces import IPendable
     >>> class SimplePendable(dict):
     ...     implements(IPendable)
     >>> subscription = SimplePendable(
diff --git a/Mailman/docs/requests.txt b/Mailman/docs/requests.txt
index cf11c3653..914ce7dfb 100644
--- a/Mailman/docs/requests.txt
+++ b/Mailman/docs/requests.txt
@@ -124,7 +124,7 @@ originally held.
 
     >>> key, data = requests.get_request(2)
     >>> key
-    'hold_2'
+    u'hold_2'
 
 Because we did not store additional data with request 2, it comes back as None
 now.
@@ -179,7 +179,7 @@ database.
     1 RequestType.held_message hold_1 None
     3 RequestType.unsubscription hold_3 None
     4 RequestType.held_message hold_4 None
-    5 RequestType.held_message hold_5 [('bar', 'no'), ('foo', 'yes')]
+    5 RequestType.held_message hold_5 [(u'bar', u'no'), (u'foo', u'yes')]
     >>> print requests.get_request(2)
     None
 
@@ -818,7 +818,7 @@ and the person remains a member of the mailing list.
     [('_parsemsg', False),
      ('listname', 'alist@example.com'),
      ('nodecorate', True), ('received_time', ...),
-     ('recips', ['hperson@example.com']),
+     ('recips', [u'hperson@example.com']),
      ('reduced_list_headers', True), ('version', 3)]
     >>> mlist.members.get_member('hperson@example.com')
     <Member: hperson@example.com on alist@example.com as MemberRole.member>
diff --git a/Mailman/initialize.py b/Mailman/initialize.py
index b17e3a9e2..0993acf3d 100644
--- a/Mailman/initialize.py
+++ b/Mailman/initialize.py
@@ -57,13 +57,13 @@ def initialize_1(config_path, propagate_logs):
     Mailman.loginit.initialize(propagate_logs)
 
 
-def initialize_2():
+def initialize_2(debug=False):
     database_plugin = get_plugin('mailman.database')
     # Instantiate the database plugin, ensure that it's of the right type, and
     # initialize it.  Then stash the object on our configuration object.
     database = database_plugin()
     verifyObject(IDatabase, database)
-    database.initialize()
+    database.initialize(debug)
     Mailman.configuration.config.db = database
 
 
diff --git a/Mailman/interfaces/database.py b/Mailman/interfaces/database.py
index 23405b9e8..f4dd693a4 100644
--- a/Mailman/interfaces/database.py
+++ b/Mailman/interfaces/database.py
@@ -30,12 +30,24 @@ from zope.interface import Interface, Attribute
 class IDatabase(Interface):
     """Database layer interface."""
 
-    def initialize():
-        """Initialize the database layer, using whatever means necessary."""
+    def initialize(debug=None):
+        """Initialize the database layer, using whatever means necessary.
+
+        :param debug: When None (the default), the configuration file
+            determines whether the database layer should have increased
+            debugging or not.  When True or False, this overrides the
+            configuration file setting.
+        """
 
     def flush():
         """Flush current database changes."""
 
+    def _reset():
+        """Reset the database to its pristine state.
+
+        This is only used by the test framework.
+        """
+
     # XXX Eventually we probably need to support a transaction manager
     # interface, e.g. begin(), commit(), abort().  We will probably also need
     # to support a shutdown() method for cleanly disconnecting from the
diff --git a/Mailman/interfaces/languages.py b/Mailman/interfaces/languages.py
index b9ddd8c90..84663cd89 100644
--- a/Mailman/interfaces/languages.py
+++ b/Mailman/interfaces/languages.py
@@ -71,3 +71,10 @@ class ILanguageManager(Interface):
 
     enabled_names = Attribute(
         """An iterator over all enabled language names.""")
+
+
+
+class ILanguage(Interface):
+    """The representation of a language."""
+
+    code = Attribute("""The 2-character language code.""")
diff --git a/Mailman/interfaces/messagestore.py b/Mailman/interfaces/messages.py
index 541238fd1..9fac98d76 100644
--- a/Mailman/interfaces/messagestore.py
+++ b/Mailman/interfaces/messages.py
@@ -99,3 +99,14 @@ class IMessageStore(Interface):
 
     messages = Attribute(
         """An iterator over all messages in this message store.""")
+
+
+
+class IMessage(Interface):
+    """The representation of an email message."""
+
+    hash = Attribute("""The unique SHA1 hash of the message.""")
+
+    path = Attribute("""The filesystem path to the message object.""")
+
+    message_id = Attribute("""The message's Message-ID header.""")
diff --git a/Mailman/interfaces/pending.py b/Mailman/interfaces/pending.py
index 68a4c41de..22d18a07c 100644
--- a/Mailman/interfaces/pending.py
+++ b/Mailman/interfaces/pending.py
@@ -40,10 +40,28 @@ class IPendable(Interface):
 
         Both the keys and values must be strings.
         """
-    
+
+
+
+class IPended(Interface):
+    """A pended event, tied to a token."""
+
+    token = Attribute("""The pended token.""")
+
+    expiration_date = Attribute("""The expiration date of the pended event.""")
+
+
+
+class IPendedKeyValue(Interface):
+    """A pended key/value pair."""
+
+    key = Attribute("""The pended key.""")
+
+    value = Attribute("""The pended value.""")
+
 
 
-class IPending(Interface):
+class IPendings(Interface):
     """Interface to pending database."""
 
     def add(pendable, lifetime=None):
diff --git a/Mailman/lockfile.py b/Mailman/lockfile.py
deleted file mode 100644
index 7db746952..000000000
--- a/Mailman/lockfile.py
+++ /dev/null
@@ -1,583 +0,0 @@
-# Copyright (C) 1998-2007 by the Free Software Foundation, Inc.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-# USA.
-
-"""Portable, NFS-safe file locking with timeouts.
-
-This code implements an NFS-safe file-based locking algorithm influenced by
-the GNU/Linux open(2) manpage, under the description of the O_EXCL option.
-From RH6.1:
-
-        [...] O_EXCL is broken on NFS file systems, programs which rely on it
-        for performing locking tasks will contain a race condition.  The
-        solution for performing atomic file locking using a lockfile is to
-        create a unique file on the same fs (e.g., incorporating hostname and
-        pid), use link(2) to make a link to the lockfile.  If link() returns
-        0, the lock is successful.  Otherwise, use stat(2) on the unique file
-        to check if its link count has increased to 2, in which case the lock
-        is also successful.
-
-The assumption made here is that there will be no `outside interference',
-e.g. no agent external to this code will have access to link() to the affected
-lock files.
-
-LockFile objects support lock-breaking so that you can't wedge a process
-forever.  This is especially helpful in a web environment, but may not be
-appropriate for all applications.
-
-Locks have a `lifetime', which is the maximum length of time the process
-expects to retain the lock.  It is important to pick a good number here
-because other processes will not break an existing lock until the expected
-lifetime has expired.  Too long and other processes will hang; too short and
-you'll end up trampling on existing process locks -- and possibly corrupting
-data.  In a distributed (NFS) environment, you also need to make sure that
-your clocks are properly synchronized.
-"""
-
-__metaclass__ = type
-__all__ = [
-    'LockError',
-    'AlreadyLockedError',
-    'NotLockedError',
-    'LockFile',
-    ]
-
-# This code has undergone several revisions, with contributions from Barry
-# Warsaw, Thomas Wouters, Harald Meland, and John Viega.  It should also work
-# well outside of Mailman so it could be used for other Python projects
-# requiring file locking.  See the __main__ section at the bottom of the file
-# for unit testing.
-
-import os
-import time
-import errno
-import random
-import socket
-import logging
-import datetime
-import traceback
-
-# Units are floating-point seconds.
-DEFAULT_LOCK_LIFETIME  = datetime.timedelta(seconds=15)
-# Allowable a bit of clock skew, in seconds.
-CLOCK_SLOP = 10
-# This is appropriate for Mailman, but you may want to change this if you're
-# using this code outside Mailman.
-log = logging.getLogger('mailman.locks')
-
-
-
-# Exceptions that can be raised by this module
-class LockError(Exception):
-    """Base class for all exceptions in this module."""
-
-class AlreadyLockedError(LockError):
-    """An attempt is made to lock an already locked object."""
-
-class NotLockedError(LockError):
-    """An attempt is made to unlock an object that isn't locked."""
-
-class TimeOutError(LockError):
-    """The timeout interval elapsed before the lock succeeded."""
-
-
-
-class LockFile:
-    """A portable way to lock resources by way of the file system.
-
-    This class supports the following methods:
-
-    __init__(lockfile[, lifetime]):
-        Create the resource lock using lockfile as the global lock file.  Each
-        process laying claim to this resource lock will create their own
-        temporary lock files based on the path specified by lockfile.
-        Optional lifetime is a timedelta specifying the number of seconds the
-        process expects to hold the lock.
-
-    set_lifetime(lifetime):
-        Set a new lock lifetime.  This takes affect the next time the file is
-        locked, but does not refresh a locked file.
-
-    get_lifetime():
-        Return the lock's lifetime.
-
-    refresh([newlifetime[, unconditionally]]):
-        Refreshes the lifetime of a locked file.  Use this if you realize that
-        you need to keep a resource locked longer than you thought.  With
-        optional newlifetime, set the lock's lifetime.   Raises NotLockedError
-        if the lock is not set, unless optional unconditionally flag is set to
-        true.
-
-    lock([timeout]):
-        Acquire the lock.  This blocks until the lock is acquired unless
-        optional timeout is greater than 0, in which case, a TimeOutError is
-        raised when timeout number of seconds (or possibly more) expires
-        without lock acquisition.  Raises AlreadyLockedError if the lock is
-        already set.
-
-    unlock([unconditionally]):
-        Relinquishes the lock.  Raises a NotLockedError if the lock is not
-        set, unless optional unconditionally is true.
-
-    locked():
-        Return true if the lock is set, otherwise false.  To avoid race
-        conditions, this refreshes the lock (on set locks).
-
-    """
-    # XXX We need to watch out for two lock objects in the same process
-    # pointing to the same lock file.  Without this, if you lock lf1 and do
-    # not lock lf2, lf2.locked() will still return true.  NOTE: this gimmick
-    # probably does /not/ work in a multithreaded world, but we don't have to
-    # worry about that, do we? <1 wink>.
-    COUNTER = 0
-
-    def __init__(self, lockfile, lifetime=DEFAULT_LOCK_LIFETIME):
-        """Create the resource lock using lockfile as the global lock file.
-
-        Each process laying claim to this resource lock will create their own
-        temporary lock files based on the path specified by lockfile.
-        Optional lifetime is the number of seconds the process expects to hold
-        the lock.  Optional withlogging, when true, turns on lockfile logging
-        (see the module docstring for details).
-        """
-        self._lockfile = lockfile
-        self._lifetime = lifetime
-        # This works because we know we're single threaded
-        self._counter = LockFile.COUNTER
-        LockFile.COUNTER += 1
-        self._tmpfname = '%s.%s.%d.%d' % (
-            lockfile, socket.gethostname(), os.getpid(), self._counter)
-        # For transferring ownership across a fork.
-        self._owned = True
-
-    def __repr__(self):
-        return '<LockFile %s: %s [%s: %s] pid=%s>' % (
-            id(self), self._lockfile,
-            self.locked() and 'locked' or 'unlocked',
-            self._lifetime, os.getpid())
-
-    def set_lifetime(self, lifetime):
-        """Set a new lock lifetime.
-
-        This takes affect the next time the file is locked, but does not
-        refresh a locked file.
-        """
-        self._lifetime = lifetime
-
-    def get_lifetime(self):
-        """Return the lock's lifetime."""
-        return self._lifetime
-
-    def refresh(self, newlifetime=None, unconditionally=False):
-        """Refreshes the lifetime of a locked file.
-
-        Use this if you realize that you need to keep a resource locked longer
-        than you thought.  With optional newlifetime, set the lock's lifetime.
-        Raises NotLockedError if the lock is not set, unless optional
-        unconditionally flag is set to true.
-        """
-        if newlifetime is not None:
-            self.set_lifetime(newlifetime)
-        # Do we have the lock?  As a side effect, this refreshes the lock!
-        if not self.locked() and not unconditionally:
-            raise NotLockedError('%s: %s' % (repr(self), self._read()))
-
-    def lock(self, timeout=0):
-        """Acquire the lock.
-
-        This blocks until the lock is acquired unless optional timeout is
-        greater than 0, in which case, a TimeOutError is raised when timeout
-        number of seconds (or possibly more) expires without lock acquisition.
-        Raises AlreadyLockedError if the lock is already set.
-        """
-        if timeout:
-            timeout_time = time.time() + timeout
-        # Make sure my temp lockfile exists, and that its contents are
-        # up-to-date (e.g. the temp file name, and the lock lifetime).
-        self._write()
-        # XXX This next call can fail with an EPERM.  I have no idea why, but
-        # I'm nervous about wrapping this in a try/except.  It seems to be a
-        # very rare occurence, only happens from cron, and (only?) on Solaris
-        # 2.6.
-        self._touch()
-        log.debug('laying claim: %s', self._lockfile)
-        # for quieting the logging output
-        loopcount = -1
-        while True:
-            loopcount += 1
-            # Create the hard link and test for exactly 2 links to the file
-            try:
-                os.link(self._tmpfname, self._lockfile)
-                # If we got here, we know we know we got the lock, and never
-                # had it before, so we're done.  Just touch it again for the
-                # fun of it.
-                log.debug('got the lock: %s', self._lockfile)
-                self._touch()
-                break
-            except OSError, e:
-                # The link failed for some reason, possibly because someone
-                # else already has the lock (i.e. we got an EEXIST), or for
-                # some other bizarre reason.
-                if e.errno == errno.ENOENT:
-                    # XXX in some Linux environments, it is possible to get
-                    # an ENOENT, which is truly strange, because this means
-                    # that self._tmpfname doesn't exist at the time of the
-                    # os.link(), but self._write() is supposed to guarantee
-                    # that this happens!  I don't honestly know why this
-                    # happens, but for now we just say we didn't acquire the
-                    # lock, and try again next time.
-                    pass
-                elif e.errno <> errno.EEXIST:
-                    # Something very bizarre happened.  Clean up our state and
-                    # pass the error on up.
-                    log.exception('unexpected link')
-                    os.unlink(self._tmpfname)
-                    raise
-                elif self._linkcount() <> 2:
-                    # Somebody's messin' with us!  Log this, and try again
-                    # later.  XXX should we raise an exception?
-                    log.error('unexpected linkcount: %d', self._linkcount())
-                elif self._read() == self._tmpfname:
-                    # It was us that already had the link.
-                    log.debug('already locked: %s', self._lockfile)
-                    raise AlreadyLockedError
-                # otherwise, someone else has the lock
-                pass
-            # We did not acquire the lock, because someone else already has
-            # it.  Have we timed out in our quest for the lock?
-            if timeout and timeout_time < time.time():
-                os.unlink(self._tmpfname)
-                log.error('timed out')
-                raise TimeOutError
-            # Okay, we haven't timed out, but we didn't get the lock.  Let's
-            # find if the lock lifetime has expired.
-            if time.time() > self._releasetime() + CLOCK_SLOP:
-                # Yes, so break the lock.
-                self._break()
-                log.error('lifetime has expired, breaking')
-            # Okay, someone else has the lock, our claim hasn't timed out yet,
-            # and the expected lock lifetime hasn't expired yet.  So let's
-            # wait a while for the owner of the lock to give it up.
-            elif not loopcount % 100:
-                log.debug('waiting for claim: %s', self._lockfile)
-            self._sleep()
-
-    def unlock(self, unconditionally=False):
-        """Unlock the lock.
-
-        If we don't already own the lock (either because of unbalanced unlock
-        calls, or because the lock was stolen out from under us), raise a
-        NotLockedError, unless optional `unconditionally' is true.
-        """
-        islocked = self.locked()
-        if not islocked and not unconditionally:
-            raise NotLockedError
-        # If we owned the lock, remove the global file, relinquishing it.
-        if islocked:
-            try:
-                os.unlink(self._lockfile)
-            except OSError, e:
-                if e.errno <> errno.ENOENT:
-                    raise
-        # Remove our tempfile
-        try:
-            os.unlink(self._tmpfname)
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-        log.debug('unlocked: %s', self._lockfile)
-
-    def locked(self):
-        """Return true if we own the lock, false if we do not.
-
-        Checking the status of the lock resets the lock's lifetime, which
-        helps avoid race conditions during the lock status test.
-        """
-        # Discourage breaking the lock for a while.
-        try:
-            self._touch()
-        except OSError, e:
-            if e.errno == errno.EPERM:
-                # We can't touch the file because we're not the owner.  I
-                # don't see how we can own the lock if we're not the owner.
-                return False
-            else:
-                raise
-        # XXX Can the link count ever be > 2?
-        if self._linkcount() <> 2:
-            return False
-        return self._read() == self._tmpfname
-
-    def finalize(self):
-        log.debug('finalize: %s', self._lockfile)
-        self.unlock(unconditionally=True)
-
-    def __del__(self):
-        log.debug('__del__: %s', self._lockfile)
-        if self._owned:
-            self.finalize()
-
-    # Python 2.5 context manager protocol support.
-    def __enter__(self):
-        self.lock()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.unlock()
-        # Don't suppress any exception that might have occurred.
-        return False
-
-    # Use these only if you're transfering ownership to a child process across
-    # a fork.  Use at your own risk, but it should be race-condition safe.
-    # _transfer_to() is called in the parent, passing in the pid of the child.
-    # _take_possession() is called in the child, and blocks until the parent
-    # has transferred possession to the child.  _disown() is used to set the
-    # _owned flag to false, and it is a disgusting wart necessary to make
-    # forced lock acquisition work in mailmanctl. :(
-    def _transfer_to(self, pid):
-        # First touch it so it won't get broken while we're fiddling about.
-        self._touch()
-        # Find out current claim's temp filename
-        winner = self._read()
-        # Now twiddle ours to the given pid
-        self._tmpfname = '%s.%s.%d' % (
-            self._lockfile, socket.gethostname(), pid)
-        # Create a hard link from the global lock file to the temp file.  This
-        # actually does things in reverse order of normal operation because we
-        # know that lockfile exists, and tmpfname better not!
-        os.link(self._lockfile, self._tmpfname)
-        # Now update the lock file to contain a reference to the new owner
-        self._write()
-        # Toggle off our ownership of the file so we don't try to finalize it
-        # in our __del__()
-        self._owned = False
-        # Unlink the old winner, completing the transfer
-        os.unlink(winner)
-        # And do some sanity checks
-        assert self._linkcount() == 2
-        assert self.locked()
-        log.debug('transferred the lock: %s', self._lockfile)
-
-    def _take_possession(self):
-        self._tmpfname = tmpfname = '%s.%s.%d' % (
-            self._lockfile, socket.gethostname(), os.getpid())
-        # Wait until the linkcount is 2, indicating the parent has completed
-        # the transfer.
-        while self._linkcount() <> 2 or self._read() <> tmpfname:
-            time.sleep(0.25)
-        log.debug('took possession of the lock: %s', self._lockfile)
-
-    def _disown(self):
-        self._owned = False
-
-    #
-    # Private interface
-    #
-
-    def _write(self):
-        # Make sure it's group writable
-        fp = open(self._tmpfname, 'w')
-        try:
-            fp.write(self._tmpfname)
-        finally:
-            fp.close()
-
-    def _read(self):
-        try:
-            fp = open(self._lockfile)
-            try:
-                filename = fp.read()
-            finally:
-                fp.close()
-            return filename
-        except EnvironmentError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-            return None
-
-    def _touch(self, filename=None):
-        expiration_date = datetime.datetime.now() + self._lifetime
-        t = time.mktime(expiration_date.timetuple())
-        try:
-            # XXX We probably don't need to modify atime, but this is easier.
-            os.utime(filename or self._tmpfname, (t, t))
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-
-    def _releasetime(self):
-        try:
-            return os.stat(self._lockfile).st_mtime
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-            return -1
-
-    def _linkcount(self):
-        try:
-            return os.stat(self._lockfile).st_nlink
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-            return -1
-
-    def _break(self):
-        # First, touch the global lock file.  This reduces but does not
-        # eliminate the chance for a race condition during breaking.  Two
-        # processes could both pass the test for lock expiry in lock() before
-        # one of them gets to touch the global lockfile.  This shouldn't be
-        # too bad because all they'll do in this function is wax the lock
-        # files, not claim the lock, and we can be defensive for ENOENTs
-        # here.
-        #
-        # Touching the lock could fail if the process breaking the lock and
-        # the process that claimed the lock have different owners.  We could
-        # solve this by set-uid'ing the CGI and mail wrappers, but I don't
-        # think it's that big a problem.
-        try:
-            self._touch(self._lockfile)
-        except OSError, e:
-            if e.errno <> errno.EPERM:
-                raise
-        # Get the name of the old winner's temp file.
-        winner = self._read()
-        # Remove the global lockfile, which actually breaks the lock.
-        try:
-            os.unlink(self._lockfile)
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-        # Try to remove the old winner's temp file, since we're assuming the
-        # winner process has hung or died.  Don't worry too much if we can't
-        # unlink their temp file -- this doesn't wreck the locking algorithm,
-        # but will leave temp file turds laying around, a minor inconvenience.
-        try:
-            if winner:
-                os.unlink(winner)
-        except OSError, e:
-            if e.errno <> errno.ENOENT:
-                raise
-
-    def _sleep(self):
-        interval = random.random() * 2.0 + 0.01
-        time.sleep(interval)
-
-
-
-# Unit test framework
-def _dochild():
-    prefix = '[%d]' % os.getpid()
-    # Create somewhere between 1 and 1000 locks
-    lockfile = LockFile('/tmp/LockTest', lifetime=120)
-    # Use a lock lifetime of between 1 and 15 seconds.  Under normal
-    # situations, Mailman's usage patterns (untested) shouldn't be much longer
-    # than this.
-    workinterval = 5 * random.random()
-    hitwait = 20 * random.random()
-    print prefix, 'workinterval:', workinterval
-    islocked = False
-    t0 = 0
-    t1 = 0
-    t2 = 0
-    try:
-        try:
-            t0 = time.time()
-            print prefix, 'acquiring...'
-            lockfile.lock()
-            print prefix, 'acquired...'
-            islocked = True
-        except TimeOutError:
-            print prefix, 'timed out'
-        else:
-            t1 = time.time()
-            print prefix, 'acquisition time:', t1-t0, 'seconds'
-            time.sleep(workinterval)
-    finally:
-        if islocked:
-            try:
-                lockfile.unlock()
-                t2 = time.time()
-                print prefix, 'lock hold time:', t2-t1, 'seconds'
-            except NotLockedError:
-                print prefix, 'lock was broken'
-    # wait for next web hit
-    print prefix, 'webhit sleep:', hitwait
-    time.sleep(hitwait)
-
-
-def _seed():
-    try:
-        fp = open('/dev/random')
-        d = fp.read(40)
-        fp.close()
-    except EnvironmentError, e:
-        if e.errno <> errno.ENOENT:
-            raise
-        import sha
-        d = sha.new(`os.getpid()`+`time.time()`).hexdigest()
-    random.seed(d)
-
-
-def _onetest():
-    loopcount = random.randint(1, 100)
-    for i in range(loopcount):
-        print 'Loop %d of %d' % (i+1, loopcount)
-        pid = os.fork()
-        if pid:
-            # parent, wait for child to exit
-            pid, status = os.waitpid(pid, 0)
-        else:
-            # child
-            _seed()
-            try:
-                _dochild()
-            except KeyboardInterrupt:
-                pass
-            os._exit(0)
-
-
-def _reap(kids):
-    if not kids:
-        return
-    pid, status = os.waitpid(-1, os.WNOHANG)
-    if pid <> 0:
-        del kids[pid]
-
-
-def _test(numtests):
-    kids = {}
-    for i in range(numtests):
-        pid = os.fork()
-        if pid:
-            # parent
-            kids[pid] = pid
-        else:
-            # child
-            _seed()
-            try:
-                _onetest()
-            except KeyboardInterrupt:
-                pass
-            os._exit(0)
-        # slightly randomize each kid's seed
-    while kids:
-        _reap(kids)
-
-
-if __name__ == '__main__':
-    import sys
-    import random
-    _test(int(sys.argv[1]))
diff --git a/Mailman/queue/archive.py b/Mailman/queue/archive.py
index b0274d49c..518a0a44c 100644
--- a/Mailman/queue/archive.py
+++ b/Mailman/queue/archive.py
@@ -20,10 +20,11 @@
 from __future__ import with_statement
 
 import time
+
 from email.Utils import parsedate_tz, mktime_tz, formatdate
+from locknix.lockfile import Lock
 
 from Mailman.configuration import config
-from Mailman.lockfile import LockFile
 from Mailman.queue import Runner
 
 
@@ -67,5 +68,5 @@ class ArchiveRunner(Runner):
         # Always put an indication of when we received the message.
         msg['X-List-Received-Date'] = receivedtime
         # While a list archiving lock is acquired, archive the message.
-        with LockFile(os.path.join(mlist.full_path, 'archive.lck')):
+        with Lock(os.path.join(mlist.full_path, 'archive.lck')):
             mlist.ArchiveMail(msg)
diff --git a/Mailman/tests/test_documentation.py b/Mailman/tests/test_documentation.py
index 825a95a3c..d8578bd05 100644
--- a/Mailman/tests/test_documentation.py
+++ b/Mailman/tests/test_documentation.py
@@ -18,6 +18,7 @@
 """Harness for testing Mailman's documentation."""
 
 import os
+import pdb
 import doctest
 import unittest
 
@@ -33,48 +34,22 @@ COMMASPACE = ', '
 
 
 def cleaning_teardown(testobj):
-    usermgr = config.db.user_manager
-    listmgr = config.db.list_manager
-    # Remove all users, addresses and members, then delete all mailing lists.
-    for user in usermgr.users:
-        usermgr.delete_user(user)
-    for address in usermgr.addresses:
-        usermgr.delete_address(address)
-    for mlist in listmgr.mailing_lists:
-        for member in mlist.members.members:
-            member.unsubscribe()
-        for admin in mlist.administrators.members:
-            admin.unsubscribe()
-        requestdb = config.db.requests.get_list_requests(mlist)
-        for request in requestdb.held_requests:
-            requestdb.delete_request(request.id)
-        listmgr.delete(mlist)
+    """Clear all persistent data at the end of a doctest."""
+    # Clear the database of all rows.
+    config.db._reset()
     flush()
-    assert not list(listmgr.mailing_lists), (
-        'There should be no mailing lists left: %s' %
-        COMMASPACE.join(sorted(listmgr.names)))
-    assert not list(usermgr.users), (
-        'There should be no users left!')
-    assert not list(usermgr.addresses), (
-        'There should be no addresses left!')
-    # Remove all queue files.
-    for dirpath, dirnames, filenames in os.walk(config.QUEUE_DIR):
-        for filename in filenames:
-            os.remove(os.path.join(dirpath, filename))
     # Remove all but the default style.
     for style in style_manager.styles:
         if style.name <> 'default':
             style_manager.unregister(style)
-    # Clear the message store.
-    global_ids = []
-    for msg in config.db.message_store.messages:
-        global_ids.append('%s/%s' % (
-            msg['X-List-ID-Hash'], msg['X-List-Sequence-Number']))
-    for global_id in global_ids:
-        config.db.message_store.delete_message(global_id)
-    flush()
-    assert not list(config.db.message_store.messages), (
-        'There should be no messages left in the message store.')
+    # Remove all queue files.
+    for dirpath, dirnames, filenames in os.walk(config.QUEUE_DIR):
+        for filename in filenames:
+            os.remove(os.path.join(dirpath, filename))
+    # Clear out messages in the message store directory.
+    for dirpath, dirnames, filenames in os.walk(config.MESSAGES_DIR):
+        for filename in filenames:
+            os.remove(os.path.join(dirpath, filename))
 
 
 
diff --git a/Mailman/tests/test_lockfile.py b/Mailman/tests/test_lockfile.py
deleted file mode 100644
index 9d6420e74..000000000
--- a/Mailman/tests/test_lockfile.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# Copyright (C) 2002-2007 by the Free Software Foundation, Inc.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-# USA.
-
-"""Unit tests for the LockFile class."""
-
-import os
-import shutil
-import tempfile
-import unittest
-
-from Mailman.lockfile import LockFile
-
-LOCKFILE_NAME = '.mm-test-lock'
-
-
-
-class TestLockFile(unittest.TestCase):
-    def setUp(self):
-        self._tmpdir = tempfile.mkdtemp(prefix='mmtest')
-        self._lockf  = os.path.join(self._tmpdir, LOCKFILE_NAME)
-
-    def tearDown(self):
-        shutil.rmtree(self._tmpdir)
-
-    # XXX There really should be additional multi-thread or -proc tests, a la
-    # the __main__ of LockFile.py
-
-    def test_two_lockfiles_same_proc(self):
-        lf1 = LockFile(LOCKFILE_NAME)
-        lf2 = LockFile(LOCKFILE_NAME)
-        lf1.lock()
-        self.failIf(lf2.locked())
-
-
-
-def test_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(TestLockFile))
-    return suite
diff --git a/setup.py b/setup.py
index 86117f083..c3458748b 100644
--- a/setup.py
+++ b/setup.py
@@ -91,7 +91,8 @@ Any other spelling is incorrect.""",
     # Third-party requirements.
     install_requires = [
         'Elixir',
-        'SQLAlchemy>=0.3.10',
+        'SQLAlchemy',
+        'locknix',
         'munepy',
         'wsgiref',
         'zope.interface',