(fix syntax error there)

We now don't buffer anything inside runTestSuite, but the generating
process itself could buffer e.g. stdout. Tell it not to do so.

if so `hostname --fqdn` errors with

	hostname: Name or service not known

Fall back to just small hostname if there is no fqdn one.

stderr is unbuffered, but by default stdout is buffered, so if stdout in
turn is redirected to be read by some other logging program, due to
buffering output could be delayed.

Don't delay the output.

We send output from tested process to master. We also print it to
stdout,stderr so it appears in testnode logs.

However till now it was like, whole output first read, and only then
emitted to log as a whole, thus not allowing to oversee current test
progress by watching testnode log tail.

Fix it by implementing the teeing process manually and using only
line-buffered mode inside.

Extracted from nexedi/slapos!282

killall is optional (comes from psmisc package) and besides `killall
runzeo` is not safe as it can be killing not only runzeo spawn from
under neotest, but also from other processes.

-> Switch to explicit kill with runzeo pid.

This is useful for development and just checking ZODB part of the
benchmarks without going first through cpu and disk parts.

run-client renamed to zbench-client for consistency.

Amends c884bfd5 (X neo/protogen: Catch length checks overflows on decode)

See https://github.com/golang/go/issues/19126#issuecomment-358743715.

Examples:

		before										after

TEXT ·(*GetObject).neoMsgDecode(SB), NOSPLIT, $8-56 // zproto-marshal.go:1914   │TEXT ·(*GetObject).neoMsgDecode(SB), NOSPLIT, $0-56 // zproto-marshal.go:1914
        // SUBQ    $8, SP                                                       │        NO_LOCAL_POINTERS
        // MOVQ    BP, (SP) (BP save)                                           │        // FUNCDATA $0, gclocals·846769608458630ae82546dab39e913e(SB) (args)
        // LEAQ    (SP), BP (BP init)                                           │        // FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) (no locals)
        // FUNCDATA $0, gclocals·21e863e2261befa92f8534560680bbb6(SB) (args)    │        MOVQ       data+24(SP), AX
        FUNCDATA   $1, gclocals·69c1753bd5f81501d95132d08af04464(SB) (locals)   │        CMPQ       AX, $24                        // zproto-marshal.go:1915
        MOVQ       data+32(SP), AX                                              │        JGE        pc45
        CMPQ       AX, $24                      // zproto-marshal.go:1915       │        MOVQ       ·ErrDecodeOverflow+8(SB), AX  // zproto-marshal.go:1924
        JLT        pc163                                                        │        MOVQ       ·ErrDecodeOverflow(SB), CX
        MOVQ       data+24(SP), CX                                              │        MOVQ       $0, _r1+40(SP)
        MOVQ       (CX), DX                     // zproto-marshal.go:1918       │        MOVQ       CX, _r2+48(SP)
        BSWAPQ     DX                                                           │        MOVQ       AX, _r2+56(SP)
        MOVQ       p+16(SP), BX                                                 │        RET
        MOVQ       DX, (BX)                                                     │pc45:
        LEAQ       -8(AX), DX                   // zproto-marshal.go:1919       │        MOVQ       data+16(SP), AX
        MOVQ       data+40(SP), SI                                              │        MOVQ       (AX), CX                       // zproto-marshal.go:1918
        LEAQ       -8(SI), DI                                                   │        BSWAPQ     CX
        NEGQ       DI                                                           │        MOVQ       p+8(SP), DX
        SARQ       $63, DI                                                      │        MOVQ       CX, (DX)
        ANDQ       $8, DI                                                       │        MOVQ       8(AX), CX                      // zproto-marshal.go:1919
        CMPQ       DX, $7                                                       │        BSWAPQ     CX
        JLS        pc212                                                        │        MOVQ       CX, 8(DX)
        MOVQ       (CX)(DI*1), DX                                               │        MOVQ       16(AX), AX                     // zproto-marshal.go:1920
        BSWAPQ     DX                                                           │        BSWAPQ     AX
        MOVQ       DX, 8(BX)                                                    │        MOVQ       AX, 16(DX)
        LEAQ       -16(SI), DX                  // zproto-marshal.go:1920       │        MOVQ       $24, _r1+40(SP)                // zproto-marshal.go:1921
        NEGQ       DX                                                           │        MOVQ       $0, _r2+48(SP)
        ADDQ       $-16, AX                                                     │        MOVQ       $0, _r2+56(SP)
        SARQ       $63, DX                                                      │        RET
        ANDQ       $16, DX                                                      │
        CMPQ       AX, $7                                                       │
        JLS        pc205                                                        │
        MOVQ       (CX)(DX*1), AX                                               │
        BSWAPQ     AX                                                           │
        MOVQ       AX, 16(BX)                                                   │
        MOVQ       $24, _r1+48(SP)              // zproto-marshal.go:1921       │
        MOVQ       $0, _r2+56(SP)                                               │
        MOVQ       $0, _r2+64(SP)                                               │
        // MOVQ    (SP), BP (BP restore)                                        │
        // ADDQ    $8, SP (SP restore)                                          │
        RET                                                                     │
pc163:                                                                          │
        MOVQ       ·ErrDecodeOverflow(SB), AX  // zproto-marshal.go:1924        │
        MOVQ       ·ErrDecodeOverflow+8(SB), CX                                 │
        MOVQ       $0, _r1+48(SP)                                               │
        MOVQ       AX, _r2+56(SP)                                               │
        MOVQ       CX, _r2+64(SP)                                               │
        // MOVQ    (SP), BP (BP restore)                                        │
        // ADDQ    $8, SP (SP restore)                                          │
        RET                                                                     │
pc205:                                                                          │
        PCDATA     $0, $1                       // zproto-marshal.go:1920       │
        CALL       runtime.panicindex(SB)                                       │
        UNDEF                                                                   │
pc212:                                                                          │
        PCDATA     $0, $1                       // zproto-marshal.go:1919       │
        CALL       runtime.panicindex(SB)                                       │
        UNDEF                                                                   │

Improves signal/noise ratio in generated decoder.

For example a list is encoded as

	l        u32
	[l]item  itemType

on decode len is read from data stream and for rest of data len(data) is
checked to be < l*sizeof(item).

However since l is u32 and sizeof(item) is just number the result of `l
* sizeof(item)` has also u32 type. However it could overflow e.g. for

	l		= 0x20000000
	sizeof(item)	= 8

with the l*sizeof(item) being = u32(0)	(exactly zero) -> oops.

Avoid the problem by doing all checking arithmetics with u64 ints.

* origin/master:
  client: kill .supportsTransactionalUndo()
  client: for read accesses, pick a random good node, connected or not
  storage: optimize storage layout of raw data for replication
  sqlite: remove useless AUTOINCREMENT for data.id (reuse of deleted ids is fine)
  storage: speed up reads by indexing 'obj' primarily by 'oid' (instead of 'tid')
  storage: pass schema of tables to migration methods
  storage: update backend version between each migration step

Usage of supportsTransactionalUndo() was removed from ZODB in 2007 - see
e.g. the following commits:

https://github.com/zopefoundation/ZODB/commit/a06bfc03
https://github.com/zopefoundation/ZODB/commit/e667b022
https://github.com/zopefoundation/ZODB/commit/f595f7e7
...

/reviewed-by @vpelletier
/reviewed-on nexedi/neoppod!8

* y/go: (25 commits)
  go/zodb/zodbtools: TODO (cmp, analyze)
  go/zodb/zodbtools: Catobj
  go/zodb/zodbtools: Info
  go/zodb/zodbtools: Dump
  go/zodb: Start of zodbtools - tools for managing ZODB databases
  go/zodb/fs1tools: Notes about other possible useful commands currently being there on ZODB/py side
  go/zodb/fs1tools: Reindex, Verify-index
  go/zodb/fs1tools: Dump
  go/zodb/fs1: Start fs1tools - tools for managing and maintaining ZODB FileStorage v1 databases
  go/zodb/fs1: My notes on I/O
  go/zodb/fs1: Register FileStorage to zodb & wks
  go/zodb/fs1: Actual FileStorage ZODB driver
  go/zodb/fs1: Add routines to (re)build and verify index from/wrt original FileStorage data
  go/zodb/fs1: Index save/load
  go/zodb/fs1: BTree specialized with KEY=zodb.Oid, VALUE=int64
  go/zodb: Start of FileStorage support
  go/zodb: Way for storage-drivers to be registered and for clients to open them by URL
  zodb/go: In-RAM client cache
  go/zodb: Minimal serialization compatibility with ZODB/py
  go/zodb: Tid connection with time
  ...

`zodb catobj` command to dump content of an object - similarly to `git
cat-file`. Two modes: raw and verbose with `zodb dump` like headers for
the object present.

There is no such command currently in zodbtools/py.

Command to print general information about a ZODB database.
Same as `zodb info` in zodbtools/py.

Add `zodb dump` command to dump arbitrary ZODB database in generic
format. The actual dump protocol being used here is the same as in
zodbtools/py with

	https://lab.nexedi.com/zodbtools/merge_requests/3

applied. (the MR there is OK and is just waiting for upstream ZODB to
negotiate a way to retrieve transaction extension data in raw form).

Add zodbtools which is generic (contrast to fs1tools) set of ZODB
managing utilities. Only package and command infrastructure here -
actual commands will follow up in the next patches.

Add commands for FileStorage index maintainance: manually rebuild the
index and to performe index verification.

Add various FileStorage-specific dump commands with output being
bit-to-bit exact with the following ZODB/py FileStorage tools:

- fsdump.py
- fsdump.py (verbose dumper)
- fstail.py

Please see the patch for links about this dump formats.