Changed the conflict resolution machinery to avoid attempting to resolve conflicts on ZClasses, because we can't import their "modules" (we don't have a db connection).

actual work

database file not to be truncated when it should have been during a
two-phase commit abort.

Simplify santiy checking of length fields in transaction metadata.
Replace the following test:
[1]    if ul > tl or dl > tl or el > tl or tl < (23+ul+dl+el):
with this one:
[2]    if tl < (23+ul+dl+el):

If any of the first three comparisons in [1] is true, then the final
test must also be true.  It's unlikely that any of the tests will be
true, so just do the final one.

This test wasn't part of read_index(), but seems good and cheap.

XXX Needs test case.

The only exceptions that an _p_resolveConflict() method should raise
are ConflictError and ValueError.  If it raises a different exception,
then it has failed.

In general, a unittest should not use a bare except clause, because
they almost always mask failures.  If the test really means to catch
all exceptions, it's best to make a comment to that effect.

self.assertEqual() and friends since this gives much better output.

Based on conversation with Evan yesterday, I think this is safe.

FCNTL is deprecated in Python 2.2 and all its functionality is
available in fcntl in Python 2.1.

Handle two new failure conditions by ignoring the index and
continuing:

    - corrupted pickle in .index file
    - no value for 'pos' in pickle (used to call long(None))

bucket when doing a "low" search.

Remove Python 2.x-isms so that tests run under Python 1.5.2

Use asyncwrap to call asyncore.loop() and asyncore.poll().
Add definition for EINTR.

Shorten two long lines, one by wrapping, another by removing an
unnecessary tuple unpacking.

Wrap send() and recv() calls in try/except

The try/except catches errors like EAGAIN that indicate transient
failures.  In those cases, treat as send() and recv() of no data and
return from method gracefully.

Fixed a bug in building undo invalidation info that caused client
storages to raise an exception that caused connections to be reset
and that, for some of reason, caused undo's to not propigate to
the clients.

Avoid long delays at the end of a pack.

    When a client calls pack, a separate thread is started to call the
    pack call on the storage.  When the thread finishes, it calls
    message_output() to send a response to the client.  If asyncore is
    currently in a poll call when this happens, the output won't be
    detected until the next poll call.  If there is little I/O on the
    connection, this won't happen until the select call times out
    after 30 seconds.

    The trigger is the standard gimmick for one thread to notify a
    mainloop in another thread that the first thread has some I/O to
    do.  It exits the current select.  The next poll call detects that
    the triggering thread is ready to do I/O and handles it.

Use asyncwrap to call asyncore.loop() and asyncore.poll()

Don't release the commit lock unless there is a transaction in
progress.  This appears to cause the "release unlocked lock" error to
be replaced with a socket.error: "bad file descriptor".  That's
progress?

Wrap asyncore calls and be careful about exceptions.

read-only protocol.

Add one case where failure to remove is not a fatal error. And be more
specific about the error that is caught -- OSError only.

implementation

from the debugging information screen.