the fan-out to fail.

When transactions are aborted, new object ids allocated during the
  transaction are saved and used in subsequent transactions. This can
  help in situations where object ids are used as BTree keys and the
  sequential allocation of object ids leads to conflict errors.

and colapsed some undo methods.

locks.

In fixing, also made it work with with.

Make lock non-private so subclasses can use it with with.

Use a more informative temporary file name.

The rpc manager can be called from the client loop if there is an error in
the client loop.

Need to call set_sender on tpc_finish result to get proper cleanup

Added a missing method

client loop.  Now the _rpc_mgr close should take care of closing
cleanly.

to avoid spurious test failures.

Fixes https://bugs.launchpad.net/zodb/+bug/516653 .

compiler silliness, but due to a threading bug which has been fixed.

------------

- As a convenience, you can now pass an integer port as an address to
  the ZEO ClientStorage constructor.

- As a convenience, there's a new ``client`` function in the ZEO
  package for constructing a ClientStorage instance.  It takes the
  same arguments as the ClientStorage constructor.

one. Added a constructor argument to give them one.

chance of affecting other tests, at least when run in a separate
process via the -j runner option.

loading index data.  This leverages the new fsBucket toString and
fromString methods and provides much faster FileStorage index saving and loading
and smaller index files.  On my machine, saves are 5 times faster and
loads are 20 times faster (after a save, when data are in disk
cache).  Indexes are roughly 30% smaller.

The index format has changed.  Old indexes can be read just fine, but
new indexes won't be readable by older versions of ZODB.

alternative to __getstate__ and __setstate__.

Also made it possible to add extra bucket methods.

Changed ZEO undo protocol. (Undo is disabled with older clients.)
Now use one-way undoa.  Undone oids are now returned by (tpc_)vote for
ZEO. Undo no-longer gets commit lock.

including those created via ``multiprocessing.Process`` instances.

This entailed giving each client storage it's own networking thread.

to be fixed. :/

- Most server methods now return data to clients more quickly by writing to
  client sockets immediately, rather than waiting for the asyncore
  select loop to get around to it.

- More clearly define client and server responsibilities. Machinery
  needed for just clients or just servers has been moved to the
  corresponding connection subclasses.

- Degeneralized "flags" argument to many methods. There's just one
  async flag.

Allow thunks to take args.

Don't hold trigger lock when calling thunks.

undoMultiple. This gives applications that want to support older
versions of ZODB a method to test for.

- The undo implementation was incorrect in ways that could cause
  subtle missbehaviors.

API changes:

- The API for undoing multiple transactions has changed.  To undo
  multiple transactions in a single transaction, pass pass a list of
  transaction identifiers to a database's undo method. Calling a
  database's undo method multiple times in the same transaction now
  raises an exception.

- The storage API (IStorage) has been tightened. Now, storages should
  raise a StorageTransactionError when invalid transactions are passed
  to tpc_begin, tpc_vote, or tpc_finish.

broken objects.