Use asyncwrap to call asyncore.loop() and asyncore.poll().
Add definition for EINTR.

Shorten two long lines, one by wrapping, another by removing an
unnecessary tuple unpacking.

Wrap send() and recv() calls in try/except

The try/except catches errors like EAGAIN that indicate transient
failures.  In those cases, treat as send() and recv() of no data and
return from method gracefully.

Fixed a bug in building undo invalidation info that caused client
storages to raise an exception that caused connections to be reset
and that, for some of reason, caused undo's to not propigate to
the clients.

Avoid long delays at the end of a pack.

    When a client calls pack, a separate thread is started to call the
    pack call on the storage.  When the thread finishes, it calls
    message_output() to send a response to the client.  If asyncore is
    currently in a poll call when this happens, the output won't be
    detected until the next poll call.  If there is little I/O on the
    connection, this won't happen until the select call times out
    after 30 seconds.

    The trigger is the standard gimmick for one thread to notify a
    mainloop in another thread that the first thread has some I/O to
    do.  It exits the current select.  The next poll call detects that
    the triggering thread is ready to do I/O and handles it.

Use asyncwrap to call asyncore.loop() and asyncore.poll()

Don't release the commit lock unless there is a transaction in
progress.  This appears to cause the "release unlocked lock" error to
be replaced with a socket.error: "bad file descriptor".  That's
progress?

Wrap asyncore calls and be careful about exceptions.

read-only protocol.

Add one case where failure to remove is not a fatal error. And be more
specific about the error that is caught -- OSError only.

implementation

from the debugging information screen.

forker.py:
    Extend start_zeo_server() on Windows with arg that specifies port,
    which is used to restart the server on the same port.

    Remove unnecessary imports.

    Set PYTHONPATH for the spawned script.

testZEO.py:
    Refactor ConnectionTests into abstract base class with two platform-
    specific subclasses.

    Add goofy test_suite() function, which is goofy because I can't figure
    out how to use unittest any other way.

winserver.py:
    Keep track of storage in ZEOTestServer so that its close() method can be
    called when the server exits.

winserver.py: A small script that runs a ZEO StorageServer and a ZEOTestServer.
    The ZEOTestServer is used to kill the StorageServer during a unit test's
    teardown phases.  As soon as a client connects to that server, it exits
    the process.

forker.py: Now forks and spawns, depending on os.
    XXX This needs to be cleaned up a lot, since the interfaces on Windows and
    Unix are nothing alike.

testZEO.py:  Add WindowsGenericTests and WindowsZEOFileStorageTests.
    These test cases use the Windows-specific forker interface.  They also
    use getStorageInfo() to describe the storage, rather than getStorage()
    to create the storage.  This is necessary because the storage instance
    is created in a separate process.

_p_resolveConflict could not handle tuples from getstate()
properly

The testrunner reports all tests passed after these changes.
Remove unnecessary path munging and attempts to import ZODB.
Update uses of whrandom to use random.

VerboseTextTestRunner() => TestTestRunner(verbosity=2)

glob() and os.remove().

properly.

writes after an abort.  This specifically flexes a bug discovered by
Shane in Full storage.

bug.

instead of any other error that may be raised.

After consultation with Jim, we agreed that Full's behavior vis object
serial numbers after a version commit/abort are correct.  The new
revision should get the serial number of the transaction that did the
commit/abort.

FileStorage is actually broken here; the new revision gets the same
serial number as the last in-version revision.  However, the way the
tests are written, it works for either storage, so I'm just updating
some comments to explain the situation.

Note: Jim also explained that history()'s "version" argument should be
ignored.  Doesn't make much difference to these tests though.

storage API.