To turn on debug logging.  A lot of interesting information helpful
when debugging network-implementation issues is logged (because
threads).

These errors were actually hidden by the test, but were annoying when
debug logging was enabled.

In ZEO.asyncio.client.Protocol.data_received, the logic was broken if
there we unhandled errors, for example in calling client storage methods.

Because normally the tests are much less patient than real life.

Some test timeouts are very low to make the tests go less slow, but
sometimes we need to wait longer.

Timeout default was False, which must have resulted from an editing
error, but we failed to pass it through where it was needed
anyway. Fixed now.

When changing addresses (think ZooKeeper :) ), we needed to be more
careful about current connection status. If we're still trying to
connect, we should stop and start over with the new addresses.

And also, we no longer do old-style cache verification.

We'll eventially deprecate the old zeo configuration, as it's
implemented in the wrong package. :) A new implementation will provide
poll-interval, however, there's not much point in configuring that.

Need to check for None as data value.

And make waiting for reconnect a little easier.

We were sending lastTransaction requests while register requests were
in-flight.  If register failed, then the lastTransaction request was
invalid, causing the connection to be closed. :(

When we update the server, we'll have register return lastTransaction
and probably info, since the client wants that information on connect.

To make matters worse, when the other site closes a connection, None
is passed to protocol connection_lost methods, which was fouling up
sornstream error detection.

Because it's only accessed by the asyncio thread.

Don't test obsolete method ``invalidate``. It's not used anymore in
master and not present on this (asyncio) branch.

Removed the reuable tests because transaction buffers are no-longer reused.

- testZEO tests now pass

- async tests now pass again

  Probably need to write more async tests to reflect changes.
  (Or maybe the ZEO tests that drove tem are enough.)

- dropped heartbeat tests, which were insane. Will add simpler test
  when I add heartbeats to the async implementation.

Many tests passing. Quite a few still failing.

- Issue with notify_connected, ClientStorage wants to make requests in
  response to being notified.  This is problematic because
  synchronsouse calls cause deadlock in this situation as do
  asyncronous calls done in a multi-threaded fashion.

  - Call get_info from io thread during startup, because
    notify_connected wants it.

  - Added an same-thread asyncronous API.

  - Added comment warning of this issue.

  - Added a little more logging.

- fixed an ordering issue when protocol is disconnected. It should
  notify the client before it cleans up it's futures to prevent
  getting more.

- Expose protocol_version to client so it can adjust it's behavior to
  the .

- More logging

- Fixed tpc_finish:

  - Use tid from server to update cache.

  - Accept and call callback function.

- Implemented flow control

- Added connection/disconnection notification (to client storage).

- implemented get_peername.

- implemented is_read_only

- renamed callAsync to async (death to Camels!)

refinements (including spelling and considering allowing tpc_finish and loads to be in flight at once.

Renamed connection_timeout to connect_poll and use it when reconnecting.

Optimized hanfline of first messagem, as we did in zrpc, because it
only occurs once. :)

More/better comments.

Move loop argument to front of constructor arguments.

Added close/close_threadsafe to wait for connection on close.

Added is_connected.

Added new_addr.

Also got rid of the adapter machinery. It didn't buy enough to justify
the wrapping.

- Moved cache into async thread to avoid lots of locking.

- Setup delegation to storage.

- Provide thread wrapper that runs the async protocol in a thread.