Got rid of PackWaitWrapper (since pack now waits by default).

Moved the connection test scaffolding to testConnection.py (new);
moved the openClientStorage() implementation into ConnectionTests.py
since it is not platform dependent.

it is in use by another thread.

__init__.  The hang was in the accept() call.  I don't understand
exactly why, but I suspect it was because we were always reusing
the same port when a trigger was closed and another opened right
away.  Fixed this by cycling over ports [19950...19999].

Also cleaned up the code somewhat.

Also changed the loop in close_conn() to go over the dict's values,
since those are all that's used.

following item:

Picklers are not re-entrant!  The only place where the shared global
pickler was used was in the error handling in store(), to test whether
the caught exception can be pickled (else it would fail when sending
the response).  Change the flow control to create a new pickler
locally, only when an exception is caught.  (When no exception is
caught, we know newserial is a string so there's no need to test its
picklability.)

in the docstring that filter should be None.  Also change the return
value if filter!=None from () to [], to match the type of what it
returns in other cases.

methods here.

the server to take the "async=0" path which could cause recursive
calls to message_input() or message_output(), which would hang due to
the input/output locks.

Use the ZEO storage id rather than the ZODB storage name.  The latter
is usually a long path to a file, which is relatively uninteresting.

Also remove unused optional argument 'last' from new_oid() and
'_stuff' from load().

Also rename _startServer() to startServer() for consistency with
shutdownServer().

When the import changed to be absolute rather than relative, the trick
of using the same Python string for the import and the getattr failed.

Add an assert() that TimeStamp is not NULL.

This is a SyntaxWarning in Python 2.3 and will be an error in 2.4.

all of ZEO from dependencies on this stealth built-in, except for some
non-unit tests).

other modules living in the same package.  It turns out that that
doesn't work when the __import__ builtin has been replaced by one
written in Python.  The easiest fix is to use absolute imports.

recv() call too, else there'd still be a race condition (two threads
both receiving some data, and then the last to read processing it
first, which would be a disaster).

read_index(); with file.name, in FileIterator.__init__().  The latter
one found by pychecker; the former by grepping for FileStorageError.

be arbitrarily long.

buffer variables here are accessed from multiple threads without any
locking@  Add such locking: a separate lock for input and one for
output.  XXX Note: handle_read() keeps the lock for a potentially long
time.  But this is required to serialize incoming calls anyway.

Unrelated nicety: use short_repr() when logging message output, for
consistency with other places.

1) An option to add the thread name to the label.  This is very handy
   during heavy debugging, but also very expensive (two extra function
   calls and some string formatting), so it is off by default; you
   have to edit this file to enable it.

2) In short_repr(), for strings, show the string quote after the three
   trailing dots.

None/1 thingies.  Also explain how state and msg_size interact.

work previously, but the combination of wait=1 and fallback mode now
works correctly -- it waits until connected.)

This prevents spurious ClientDisconnected exceptions.

No jokes about sharing pickles please. :-)

is *not* thread-safe.  So don't share the Pickler.