not used outside neonet.

Don't try to play with file.readline() - that seems to be working for
usual cases, but:

1. it does not work for cases when e.g. a dot is printed for every test
   run on the same line (e.g. neo/py tests, pytest, etc...)

2. in case when there is a lot of output available ready to be read it
   would be a waste of resources to read/flush it line by line.

-> use raw OS read with sane semantics.

(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