- some cleanups
 - re-introduced a way to ask for a rename() operation but fall back to copy
   if rename doesn't work
 - using the rename_or_copy for blobs where reasonable
 - fixed a test that was trying to test a failing consumeBlob but where the
   wrong exception was tested for

   new uncommitted data.
 - Made blobs use the temporaryDirectory() method of storages to store new
   uncommitted data near the committed data.

Removed the soon to be replaced readDetached,

Hack os.rename rather than the blob to avoid a testing artifact in the
blob implementation.

- Unwritten blobs can now be read, and are empty.

- Blobs are considered modified when opened for writing.  This is a
   little bit more conservative than before but fixes a bug that a file
   opened with 'w' actually does modify the file and wasn't considered
   to be a change before.

- Optimistic savepoints now work.

- Fixed bug: could open multiple files for writing.

- Fixed bug: aborting a transaction removed uncommitted data for
   uncommitted blobs.

Todo: 
   Need to remove uncommitted data file if a blob is GCed even when a
   transaction isn't aborted or when it hasn't been added to anything.

- No-longer close files on transaction boundaries.

This allows us to get rid of the transaction-manager dance.

object is a blob.  YAGNI support for multiple blob implementations --
at least for now.

   closed connections.

away -- even before they are placed in the cache.  This causes a
problem if the object's state has a (direct or indirect) reference to
it. Added a pre-cache that allows the connection to return objects
alreadey being loaded when necessary.

module).

- Avoid more than one round-trip call when loading blobs via copy from
  the server.

- Avoid loading large amounts of blob data into memory.  The old
  storeBlob implementation was likely to queue blob adta faster than
  it could be sent, leading to a large memory foot print for the
  queue. Now, iterators are used to read data from files only when the
  network layer is ready to send it.

- Fixed storeBlob to move the input file to the blob cache (when not
  sharing the blob directiry with the server).

- Extended the loadBlob locking model to work with multiple processes
  by using file locks rather than threading locks.  A common
  configuration is to use a client process per core, so that a machine
  is likely to have many client processes and it should be possible
  for the client processes to share a common blob cache.

Now it also truly consumes files.

Binary mode is implicit.

all OS files in binary mode.  Binary mode for blobs is now implicit.

Added a temporaryDirectory method for getting a directory to use for
creating temporary files.

temporary directory to work around current blob limitations that blob
files and storage blob directories need to be on the same device.

use an iterator to send a large file without loading it in memory.

Updated the ZEO protocol to reflect the new Blob-support methods.

use an iterator to send a large file without loading it in memory.

- Found and added a test for a race condition arising from creating
  and removing lock files.

- Change to leave lock files behind.

- Use the windows locking implementation from msvcrt from the standard
  library, rather than using a custom extension module.

to die when removing test directories.

to give time for servers to stop, since windows won't let us remove
files or directories if they are in use.

Windows when Blobs aren't used.

Fixed a typo.

generate it's own invalidations.  Also updated to honor the storage
APIs more carefully.  These changes together allow a ClientStorage to
be served by a storage server.