It's not clear what the right answer is here.  The implementation
aborts any remaining resource managers and hopes for the best, which
isn't very satisfying.  Perhaps the hosed feature should come back.

Add some comments about the issues involved.  Revise the tests to
cover the current behavior.

XXX Should the manager duplicate these checks?

Make txn_factory an attribute of the base class.

Raise an exception when prepare() returns False, rather than
automatically aborting.

Pass transaction object to Rollback() so that rollback() method can
check state of transaction.

Add IllegalStateError calls to prevent assertions from failing.
XXX Should the manager duplicate these checks?

Add suspend() and resume() to non-threaded txn manager.

Fix bug that caused threaded suspend() to fail with KeyError for
thread with no current transaction.

classes.

If an error occurs during tpc_finish, save the original exception just
in case something goes wrong while cleaning up the message.

Add suspend() and resume() to transaction manager API.
Change implementation so that the thread-aware manager does not
inherit from the thread-agnostic manager.
Add suspended transaction state.

Increase by iterating for longer, rather than making the delay
longer.  This helps the tests go fast on faster machines.

It's too much work to try to get these tests to work, considering that
we are declaring start.py obsolete with the 3.2 release.

Print repr of description instead of str.

Pederson.  The 'wrap' local variable was reused in a way that
overwrote the value intended to set the return dictionary.

which is used by Barry's new LockFile class.  The effect of leaving
regions of a file locked when closing the file, or when exiting the
process, is undefined on Windows, and the new scheme restricts itself
to operations with defined semantics.

encapsulation the storage lock file.

unlock_file() call which awaits Tim's backport of
winlock.UnlockFile().  This is no-op on *nix.

Also, implement a better API for dealing with lock files.  Use the
LockFile class for clean acquisition and release of locks, and
unlinking of lock files.

- add missing period

- normalize some markup usage

- fix lots of typos

types that grow an __module__ in future versions of Python.

- minor cleanup

reconsidered.  That's for another day, though.

- use constant from errno module instead of magic number

    Needed since we're not actually waiting for the ZEO server process
    to exit (it's a grandchild, not a child).  It we don't wait,
    there's a race condition between one test and the next -- if the
    ZEO server isn't done shutting down, the database may still be
    locked when the next test starts.

it just uses the gzip module's default compression level (i.e. 9).

No need to specify -z on recovery because the script will
automatically uncompress gzip'd files.  It does this by looking at the
file extension, which will be .fsz or .deltafsz for compressed files.

incremental instead of all the incrementals.  Less assured consistency
but much less disk i/o.

saving state in a pck pickle file, and doing an incremental parse the
next time.  Specifically:

Added -f and -r flags.  The -f flag points to the pickle state file
(by default ./zeoqueue.pck).  The -r flag simply removes this file.
This is useful for log rotation in the cron job, and yes rm would have
been fine, but this option was requested by customers.

process_file(): Added to Status class so that the processing is done
here, where we can seek to a stored file position.

Also added the secret -0 option for testing, which suppresses the file
position seek (useful when the log file is split into chunks).

Return the number of blocked clients as the exit status code.

Also, avoid storing wrappers.

Added a module docstring as a usage() string.  Also add --help/-h.

Rewrote two of the regexps as verbose re's for readability <wink>.
Use named groups.

Use True/False where appropriate.

Txn: Added a `voters' attribute which is a list of clients seen doing
a vote.  This is cleared on abort or finish.  Thus if we see a
transaction with a non-empty voters list, we know that that
transaction was blocked and it was the first voter that grabbed the
lock.  This client (as an address) is displayed in the report.

call_*(): Pass the client address into the call, as grep'd out of the
zrpc-conn part of the line.  Only call_tpc_vote() really cares about
this.

Most controversial: process the entire file, line by line.
Alternatives, if necessary:
    - go back to the original progressive skip backwards approach
    - add an incremental reader (recording file positions)
    - use as a filter