Cleanup comments for Managed*Connection.

Whitespace normalization.

- It never uses self.conn.  So don't store it.

- Make a check in register() that register() isn't called twice.  If
  it is, log a message and raise ValueError.

trying to fake a tpc_abort() call with the right transaction id, call
a new method abort(), which resets some instance variables and then
calls the strategy's abort() method.  The immediate strategy's abort()
aborts its own transaction and then calls the zeo_storage's
handle_waiting() method to restart the next blocked transaction from
the _waiting list; the delayed strategy's abort() removes the
zeo_storage from the _waiting list.

- Remove unused imports.

- Got rid of \ continuation lines.

- Remove leading underscores from all names of methods and instance
  variables of ZEOStorage.  There was no usage consistency and I don't
  see any other reason to maintain the existing names.

a variety of exceptions.  Catch all of them.  (The only ones I've seen
are Disconnected and ReadOnlyError, but since we're disconnected
abruptly as part of the switch, it's possible to see any of the
exceptions that checkReconnection() catches.)

read-write server now works!!!

unlocking bug in new_oid().

the _server.new_oids() raising Disconnected or ReadOnlyError).  Fixed
by adding a try/finally.

randrange(25000, 30000) to get one random port each time _getAddr() is
called.

Otherwise, when running the tests in an endless loop with "test.py
-L", eventually tests start failing because they're out of ports.

the client, don't log it at the ERROR level.  If it really was a
disaster, the client should log it.  But if the client was expecting
the exception, the esrver shouldn't get all upset about it.  Change
this to the INFO level.  (When it *is* considered an error by the
client, it's useful to be able to see the server-side traceback in the
log.)

hits found in the non-current file into the current file.

For the 40-hour trace starting on Sept 4 at 6pm, this increases the
hit rate from 83.2% to 87.0% (IOW a decrease in miss rate from 16.8%
to 13%):

ZEOCacheSimulation, cache size 200,000,000 bytes
  START TIME  DURATION    LOADS     HITS INVALS WRITES  FLIPS HITRATE
Sep  4 18:00  40:36:34  1420070  1181176  16198  10014     15  83.2%

AltZEOCacheSimulation, cache size 200,000,000 bytes
  START TIME  DURATION    LOADS     HITS INVALS WRITES  FLIPS HITRATE
Sep  4 18:00  40:36:34  1420070  1235770  15384  10014     25  87.0%

any difference on Win2k.  Add XXX comment with question about
WSAEALREADY.

Made progress with the reconnect tests.  The simple ones now work.
The trick was to call asyncore.poll() until the client is
(dis)connected before going to the next phase of the test; I added
pollUp() and pollDown() helper methods for this purpose.

The reconnect "upgrade" test doesn't work yet.  That is, a client is
created in fallback mode, initially connecting to a read-only server.
So far so good.  Then the server is shut down.  Somehow an attempt to
store once the server is down simply *hangs*.

No progress with the multiple server fallback test.

(now redundant) pid=%s part from that first log message.

Change label to ZSS:pid.  Re-initialize pid every time a StorageServer
is created.  XXX This is sufficient as long as a single process
doesn't create more than one StorageServer instance.  I haven't found
any code that does.

Use log() function for self.log() method of ZEOStorage, so it ends up
sharing the ZSS:pid prefix.

Caught by Guido, but why not be my compiler?

It was calling repr() twice on the elements of a tuple.  Fix by
calling repr() explicitly on each branch of the type-test code.

Add comment about how short_repr() is used.

Reformat all the code to use Python style.

We got an undiagnosed bug report for coptimization, which lead to an
attempt at code review.

Break up a the large new_persistent_id() function into several helpers
-- get_class(), get_class_tuple(), and set_oid().  Each function now
does a little less.  Don't reuse variable names for random purposes.

parallel outstanding calls.  However it also contains code (by Jeremy,
with one notifyAll() call added by me) that enforces the old rule of a
single outstanding call.  This is hopefully unnecessessary, but we
haven't reviewed the server side yet to make sure that that's really
the case (the server was until now getting serialized calls per
connection).

checkCommitLock2On{Abort,Commit}.  When
ZEOStorage.notifyDisconnected() calls self.tpc_abort(), it is possible
that self.strategy is DelayedCommitStrategy.  In that case,
ZEOStorage.tpc_abort() should *not* call self._handle_waiting(),
otherwise there could be two ZEOStorage instances whose strategy is
ImmediateCommitStrategy!

true.  Use 0 for false instead.

true.  Use 0 for false instead.

    try:
        self.lock.acquire()
        ...
    finally:
        self.lock.release()

into:

    self.lock.acquire()
    try:
        ...
    finally:
        self.lock.release()

The old version would mistakenly try to release the lock if there was
error in acquiring it.

This code used to assume that all arguments were strings.
It was always wrong (create was passed as '0' or '1' rather
than as 0 or 1) but this was somehow masked.  When I added
readonly, things broke.  The solution is that winserver.py
ha a convention that an argument starting with '=' is
evaluated as an expression, and _startserver in testZEO's
WindowsConnectionText uses this for the create and readonly
args.

wide xterm or emacs window.  So now, when using Python 2.3 or later,
the textwrap module is used to wrap the message line, indenting
subsequent lines past the timestamp.  Details and tracebacks are left
alone.

Add a LOG call to ConnectionTests.setUp().

Add tests for the ClientStorage read_only and read_only_fallback
features.  Note that the latter feature is not completely working yet;
the reconnect feature doesn't work, so it's of questionable value for
now (though it *does* connect to a read-only storage whe no read-write
storage is available).

read_only_fallback option of ClientStorage.

Unfortunately, this still doesn't work completely; as shown by some
disabled tests that I'll check in shortly, the reconnect feature is
still broken.  But it's weekend time, and I need a checkpoint to keep
my own sanity.

"ClientStorage <pid>", use "ClientStorage:<pid>".

Also log a message when a ClientStorage instance is created, showing
the pid, the read_only and read_only_fallback parameters, and the
storage name.

Also log some more things: the retry of the register() call with
read_only=1, the notifyConnected call,

Also clean up a few comments and docstrings, removing one XXX that
seems out of date.

Also change the _tpc_cond.wait() method call into a wait(30).  That
way it is interruptable.

StorageServer class, instead of "ZEO Server:<pid>", use
"StorageServer:<pid>".  In the ZEOServer class, instead of "ZEO
Server:<pid>:<name>", use "ZEOStorage:<pid>:<name>".

Also log a message when a StorageServer instance is created, showing
the pid, the read_only parameter, the storage names, and for each
storage whether it is RO (read-only) or RW (read-write).

Also clean up a few comments, removing one XXX that seems out of
date, and use %r instead of %s in some log messages.

name, cache size, and current filename (could be None).

"ZEO Server", use "ZEO/start.py".  There was one (PANIC) log message
that used "z2"; changed that one to "ZEO/start.py" as well.