__init__(): __closed = 0
connect(): In connecting thread, don't continue if __closed is true.
close(): __closed = 1

If one thread was committing a transaction and another thread was
opening a new DB connection, deadlock could occur.  The cause of the
deadlock is that tpc_finish() acquires the storage and db locks in a
different order than DB.open().  As a result, if each starts at the
same time and gets one of the two locks it needs, the system will be
deadlocked.

The solution is to enforce a consistent locking order.  If a thread is
going to hold the DB lock and the storage lock, it MUST acquire the DB
lock first.  This patch implements that locking order for the
invalidation in tpc_finish().

The DB object gets methods called begin_invalidation() and
finish_invalidation() that acquire and release the DB lock
respectively.  Before the Connection calls tpc_finish() on the
storage, it calls begin_invalidation().  This guarantees that the DB
acquired before the storage lock.

When the invalidation phase is over, the Connection calls
end_invalidation() to release the DB lock.  This is an optimization.
It could wait until tpc_finish() returns, but we know that the DB will
not be used again for the rest of the tpc_finish() and tpc_finish()
could take a long time.

Specific changes:

DB.py
begin_invalidation(): Added.
finish_invalidation(): Added.
invalidate(): Remove locking.
invalidateMany(): Add comment about how it should be used.

Connection.py
tpc_finish(): Don't pass second argument to storage's tpc_finish()
    when committing a transaction with no data.  Add call to
    begin_invalidation() before calling storage's tpc_finish().
_invalidate_sub(): Remove empty, unnecessary method.
_invalidating_invalidating(): Add call to finish_invalidation() after
    last call to DB's invalidate().

Eventually, we should add registration for the other flavors too.
This will require deciding how to specify the II, IO, OI variants. ;)

Fixed a type that prevented import.
Changed interface registration to take advantage of the fact
that we have classes.

Fix bug reported by John D. Heintz.

"supportsTransactionalUndo()" method.

XXX untested

XXX This mechanism for feature evolutional doesn't seem right, because
it because a morass of backwards compatibility issues.  I'd rather see
the test by one of presence/absence of an attribute or a base class.

storage in all their many flavors.

This fixes a conflict resolution bug with subtransactions.
XXX Commit same change of zope-2_3-branch.

A related change in store() is to call _handle_serial() *after*
putting new objects in the cache.  This simplifies the logic of
_handle_serial() a bit, because every object should be in the cache.

sub-transactions

XXX Need to apply effbot's lambda-refactoring pattern

Use types module rather than type().
Fix indentation nit.

misnamed, because it's also the min_connect_poll and it makes the
tests run much faster by waiting for a shorter period of time between
connect attempts.)

Add makeTestSuite() helper that replaces clunky unittest mechanisms.

any recent updates are written to the file.

Remove seek() and tell() at the beginning of read_index() because
their results are not used.

Add main() that prints the contents a cache file when executed as a
script.

Add a log call when the cache is being read.

Add optional cache_size argument.

Also print # conflicts for each test (appears to be zero).

different depending on whether the version is different.

The invalidated oids (and versions) get written to the tempfile, and
are invalidated during the tpc_finish().

separate class

Support for using basic multi framework with other run() functions.

XXX The two cache invalidation tests fails currently.

storage id

The cdata and cver had been swapped, causing all undos to fail,
because the version was compared to a pickle.

checkBuggyResolve2() -- _p_resolveConflict takes too few args
checkUndoConflictResolution() -- make sure conflict resolution is
     invoked properly during transactional undo
checkUndoUnresolvable() -- make sure transactional undo can cope with
     failed conflict resolution

Add new tests for conflict resolution.

The old blanket try-except for conflict resolution was hiding some
bugs caused by the pickles used in the test suite.  The conflict
resolution code imposes some restrictions on the format of pickles.
Basically, the conflict resolution requires that the storage API only
accept a pickles that constructed according to the ZODB rules.

XXX This new restriction sounds unfortunate, but it would require a
substantial change to conflict resolution to remove it.

The key changes to the test suite are to store only persistent objects
and to format the pickles using the standard ZODB format.  All tests
now use ZODB.tests.MinPO.MinPO instances for data.  The pickling is
down with zodb_pickle() and zodb_unpickle() defined in
StorageTestBase.

Add conflict resolution tests to testFileStorage.  (They pass.)

The value of _loadBack() -- a pickle and a serialno -- was being
passed to tryToResolveConflict() where only a pickle was expected.

XXX _loadBack() can raise KeyError, but this wasn't handled by the
code.  Turn into UndoError() for now.