The previous code just called tpc_abort() on the server, but that
wouldn't restart any waiting transaction.

- Add some expository comments.

- Add some asserts documenting non-obvious assumptions.

- Make modifiedInVersion a delegated method, since it does nothing
  special.

- Fix a bug in undo(); it was passing a list of triples (oid,None,'')
  to the server.invalidate() call rather than a list of tuples
  (oid,'').  There are no unit tests for undo(), so this was never
  caught.  I guess few people care about undo() now that we have
  transactionalUndo().

- In ImmediateCommitStrategy.store(), only catch exceptions that
  inherit from Exception raised by the storage's store() call; the
  client is only checking for those in the list of serials.

- Remove unused instance variable 'invalidated' from the
  DelayedCommitStrategy class.

client.  Remove it from the stub.

names and Python method names.  (Checked this in on the trace branch
by mistake.)

Change the wire protocol back by providing aliases.

Log cache flips and non-trivial read_index statistics (at info level).

Move RCS info into docstring.

Add XXX TO DO comment at top.

Whitespace normalization.

Also, reformat the _finish() method and add some comments.

same as the serialno in the last non-version data record.

XXX This might be the only time that the serialno of a data record
does not match the transaction id.

Remove checkNewSerialOnAbortVersion and checkNewSerialOnCommitVersion.
They duplicate checkCommitVersionSerialno and checkAbortVersionSerialno.

public API.

Open the cache later to avoid scanning it twice if a connection is
made right away.

ClientStorage.close() is now idempotent.

ClientStorage stores its addr argument as self._addr so the test suite
doesn't have to dig it out of the rpc manager to reopen the storage as
readonly.

Renamed some of the callbacks into the client for clarity:
begin -> beginVerify
end -> endVerify
invalidate -> invalidateVerify
Invalidate -> invalidateTrans

Also refactor the test code to use _abortVersion() and _commitVersion().

Note that the checkModifyAfterAbortVersion() test still fails; Jeremy
wants to change abortVersion in FileStorage and DemoStorage to revert
the serialno to the last nonversion serialno instead of assigning a
brand new serialno, so I'm holding off on invalidating the cache in
ClientStorage.abortVersion.

Also note that on Red Hat 7.2, the ZEO test suite hangs in
checkCommitLock2OnAbort or checkCommitLock2OnCommit; we'll try to
debug this later today.

serials. Modified FileStorage and DemoStorage to pass this test.

In checkSize(), delete the half of the index that's no longer valid.

erase the half of the _index dict that is invalidated by the flip.

identification harder, especially when generic test classes are
inherited by multiple specific test classes.)

- Document the correct persistent filenames and the presence of a
  magic number at the start of the file.  (Also document the
  conditions under which the cache is persistent.)

- In __init__(), seek to the correct position to read the first
  record's serialno.  It was reading the last byte of dlen plus the
  first 7 bytes of the serialno.

- In invalidate(), fix the seek call after the read(8) to actually
  seek to the status byte.  It was seeking 8 bytes too far, causing it
  to overwrite the 2nd byte of dlen instead of the status byte.

This will cause three failures with the current version of
ClientCache.py, because some of the tests were specifically written to
verify certain bugs.  I will check in fixes for thse bugs shortly.

Use STUPID_LOG_FILE instead of EVENT_LOG_FILE so that it works with
older Zopes.

Make sure buf1 is defined even if open() never succeeds.

The one in ZEO/trigger.py was the good code, but we want it to live in
ZEO/zrpc/trigger.py.  This checkin makes that change.

The key checkin of ZEO/trigger.py had this checkin comment:
Fix trigger close/__del__.

The close() mechanism for an asyncore file_dispatcher is not safe to
call multiple times.  It's calling os.close() on a file descriptor
(int).  Guido observed that if you call close() twice, you could be in
trouble:  1) First close() call closes FD 6.  2) Another bit of code
opens a new file, getting FD 6.  3) Second close() call closes FD 6.
Waah!  FD 6 is some other file.

The workaround attempt here is to define a close() method on a trigger
that only closes the file descriptors the first time.

Also, make sure that both file descriptors are closed.  The previous
version only closed the read-end of the pipe.

Boost the accumulator limit to 60000.
Use "".join() to accumulate multiple strings, since it is not unusual
to have more than 2 strings to join together.

Add comment explaining why we do this stuff.