We already have "testing connection" functionality in common place (was
named tPersistentDB -> now tConnection). However the functionality to
"setup and use testing database" was inside TestPersistentDB only.

Since we are going to add more tests, factor that functionality out of
TestPersistentDB into shared infrastructure that could be reused in
between tests (-> tDB).

It was printing oid instead of obj.

Provide functions to:

- set cache element
- iterate through all elements

LiveCache organization will be changed in the following patch, and it is
better to keep the knowledge about its internal structure localized.

For ZODB we always open database at storage level. Thus `zodb.Open(zurl)`
is relevant. At application level we open database creating DB from
IStorage and using DB.Open() .

Today LastTid is ambiguous: does it return locally cached last transaction ID,
or it performs round-trip to server to get more uptodate view of what has been
last committed? As the result of this ambiguity some drivers (e.g. FileStorage,
ZEO) return cached view, while other drivers (upcoming NEO, living on t branch)
was doing the full round-trip.

There are also situations where whether or not LastTid performs syncing to
server affects semantics: for example if there are two ERP5 nodes and one
node commits something into ZODB and conveys the fact that something has been
committed via another channel, the second ERP5 node should have a reliable way
to observe committed data. But currently there is no such way: on next DB.Open,
even with at=0 meaning "use latest transaction" and with opt.NoSync=false,
DB.Open uses storage.LastTid() as a way to sync and oops - for some drivers it
won't result in real synchronization and thus opened connection could
potentially have older view with not yet latest data.

To fix this ambiguity require drivers to provide Sync functionality only. That
should return ID of last transaction committed to storage data as observed from
some time _afterwards_ Sync call was made. In other words for particular
client-server case, Sync cannot return cached view of storage and has to
perform round-trip to the server.

At IStorage level we provide two entry points: Sync, to perform syncing, and
Head that returns database head (last transaction ID) as viewed by local cache
without any synchronization.

Please see changes to IStorageDriver and IStorage interfaces for details.

The rest of the changes are:

- teach zodb.storage (the IStorage implementer) to actually implement Sync/Head.
- adapt zodb.DB to perform Sync for !opt.NoSync case.
- teach FileStorage to do proper syncing instead of returning local cache.
- teach ZEO to perform "lastTransaction" RPC call for syncing instead of
  returning local cache.
- adapt the rest of the tree to interfaces change.

If we use only the rule that we keep last 10 minutes of database
history, and commits come less often than that - e.g. once per 30
minutes, on every new commit we'll be throwing away all δtail data,
which would result on completely throwing away live cache on every
DB.Open .

Add another rule to cover seldom updates spectrum so that we never throw
till empty δtail and keep at least 10 elements in δtail queue. This will
make sure that live cache is preserved even when updates to database are
seldom to come.

Tests pending...

This gives access to raw data stored in ΔTail. We'll need this in the
next commit, as well as going through raw δtail data is also generally
useful.

Add low-level option to resync Connection to another database state with
preserving its live cache.

Wendelin.core needs this for its main ZODB connection because it needs
to carefully propagate ZODB invalidations into file invalidations and
semantically relies on objects staying in ZODB live cache for this to
work correctly:

https://lab.nexedi.com/kirr/wendelin.core/blob/455a54425c/wcfs/wcfs.go#L245

Implement invalidation handling to teach DB to reuse Connections from
connection pool: after connection is returned to the pool on transaction
completion, we can use this connection for next DB.Open(at) request, by
seeing which objects we changed in conn.at..at range and invalidating
those objects in connection live cache.

To know which objects were changed, DB adds watch on its storage and
maintains some history tail (using ΔTail - see previous commit).

Finally add test for both DB and Connection, and also for Persistent,
LiveCache, ... - as all those application-level components are tightly
inter-related.

Add ΔTail - utility class to keep track of history tail of revisional
changes. This will be needed for both DB (to handle invalidations) and
for raw Cache(*). It also might be useful in places outside of zodb/go -
for example WCFS from Wendelin.core uses ΔTail to keep track of which
ZODB revision changed which block of file(+).

Please see ΔTail comments for details.

(*) to check a bit ahead on load to see whether loaded serial is
actually the latest one for ≤ Cache.head, and, if yes, mark
corresponding cache entry as having .head="current" so that the entry
coverage could be extended when Cache.head is extended to cover more
database state instead of loading the same data from the database again.

(+) that's why we have δtail.go.cat-generic, so that third-party
packages could adapt ΔTail to needed types.

We are going to add more options. Adopt "!" prefix as "no" for
something. Make the code flow in ConnOptions more suitable for further
additions without changing formatter for previous option.

DB is a "handle to database". It has to be closed to release its
resources when no longer needed. We don't have to release anything
currently, but that will soon change in a followup patch.

Due to forgotten ... it was not passing prepared argv as argv to
fmt.Errorf, but as a single slice argument. The result was messy, for
example

    persistent_test.go:176: deactivate refcnt < 0: panic error unexpected:
        have: "[t.zodb.MyObject 000000000000000c](%!s(MISSING)): deactivate: refcnt < 0"
        want: "t.zodb.MyObject(000000000000000c): deactivate: refcnt < 0"

Using the occasion add details to deactivate refcnt panic, which
made me to discover this bug.

Seeing all problems helps to understand what is going on, compared to
e.g. if it complains only about .jar being wrong.

Persistent.refcnt is int, %s prints it as e.g.

	%!s(int=1)

-> use %d.

We are going to use this function in other tests too.

We were not actually checking for it and it is hard to check correctly
since .loading is transient.

Add new `zodb watch` command that is both demonstration of just added
ZODB Watch API (see previous patch), and could be useful for a ZODB
database administration / monitoring.

See zodbtools/watch.go for description.

Add initial draft for IStorage-level watch API and implemention:

- Notifier goes away;
- Add Watcher interface instead with AddWatch/DelWatch calls. See
  Watcher documentation for details.
- IStorage wrapper now subscribes to driver events, retranslate them
  to users and handles Add/Del watch subscription requests.

XXX Raw cache becomes temporarily disabled, until it is fixed to handle invalidations.
XXX Tests pending.

storage is a wrapper that turns IStorageDriver into IStorage. It will
have some logic around almost all IStorageDriver methods. So don't
automatically inherit driver methods not to miss some.

It is already not only open code there, and we are going to add more
storage wrapping functionality into storage (IStorage wrapper over
IStorageDriver). Storage.go thus seems to be a better name.

This continues 4d2c8b1d (go/zodb: Require drivers to provide
notifications for database change events) and a6580062 (go/zodb: Require
drivers to provide at₀ on open) and reworks watchq to receive not only
commit events, but also errors from watcher in storage driver.

Similarly to zodb (632c9798 "go/zodb: storageURL -> zurl")

This are equivalents of PersistentMapping and PersistentList in ZODB/py.
PersistentMapping is usually used as root ZODB object in Zope/ERP5/...

At least we should be able to load and save them now.
Tests pending...

zurl is more handy and is also used in zodbtools which have help on it
(`zodb help zurl`).

BTrees.Length.Length is used in many places in ERP5. At least we should
be able to load and save it now.

Tests pending.

This functions invoke visit callback on every BTree node they traverse.

Wendelin.core needs this to retrieve serials of not only looked up ZBlk
object, but also of every BTree nodes on the path to it.

go/zodb/btree: Bucket.Get: Don't get ctx argument and just require that the bucket must be already activated

It was scheduled to be so as described in removed TODO.

It is either BTree or Bucket.

This will allow persistency layer to do kind of copy-on-write, if e.g.
there are many connections that are sharing object's state.

Continuing previous patch also teach ZEO to decode identifies from
on-wire as both [8]str or [8]byte.

Tests pending.

Since ZODB 5.4 OID is encoded as bytes, not str:

	https://github.com/zopefoundation/ZODB/commit/12ee41c473

Try to support both str and bytes on decoding, as we need to support all
ZODB versions.

Add a way for tests to serialize and commit IPersistent objects. The
commit, for now, is implemented via calling external zodbtools/py to
commit raw data (see 7f14e2cb "go/zodb/fs1: tests: Factor-out commiting
a transaction via ZODB/py into common place). The data to commit is what
object serialization (see previous patch) gives.

For now there is no tracking of dirtiness. A test must explicitly list
objects it wants to save into database.

This functionality will soon be used to implement Persistent/DB/...
tests.

This will be used in the future to commit object changes back into
database. No test, since this functionality will be used at first to
implement tests themselves (see next patch). Hopefully after
bootstrapping we'll have full tests.

- require (Py)GetState and make it clear that it is called by
  persistency machinery only on non-ghost objects.
- make it clear that (Py)SetState is called by persistency machinery
  only on ghost objects.
- make it clear that DropState is called by persistency machinery only
  on non-ghost objects.

For btree PyGetState is marked as TODO which we'll fill incrementally
(the code is draftly ready, but there is no test for now).

We will soon need to be able to commit in tests for ZODB itself.

and to deliver to watchq only and all events in (at₀, +∞] range.

This continues 4d2c8b1d (go/zodb: Require drivers to provide
notifications for database change events) and makes initialization
semantics to process invalidations easier for both application-level ZODB
layer, and for low-level users that work with drivers directly:

- there is no possibility that an event will come from watchq with tid <
  current user head.

- there is no possibility that watcher will start delivering events
  after at₀, but not immediately after it, i.e. users can rely that they
  won't loose an event.

This correctness invariants should be easy to provide in drivers.

pool is a better name for "pool of unused connections" compared to connv.