Remember the lsn of the last checkpoint when backup starts and make sure
that box.internal.gc doesn't delete any files that are needed to recover
from this checkpoint or a newer one until backup is stopped.

Previous vylog file is required for backups. Currently, we preserve it
on garbage collection only if there have been no snapshots since backup
started, otherwise it will be removed by box.internal.gc, which will
break backup. Fix this by skipping the vylog file that was created
before the lsn passed to box.internal.gc.

Actually the bugged test must hang tarantool, but it didn't
because of a bug in vinyl commit, that will be be fixed later.
Fix a bug in the test anyway.

See #2280

It's unclear how to backup an indexe with custom path. Since the user
can effectively store files of a vinyl index in any directory with the
aid of symbolic links, let's just drop this option.

We might need it, e.g. for merging runs at the master's side
on initial join.

Move them to key_def.cc and make them suitable to be used from C.
This is needed to store key_def in the vinyl metadata log.

index_def_set_part() does not need a full index definition,
a key_def is enough.

Add box_tuple_compare_with_key to module api. See #2225

Add "--replica=replica_id" option to `play` and `cat` commands.

Fixes #2301

In case of system runs under systemd - start/stop global instances using
systemd.

closes gh-2254

Bikeshed to simplify merge of gh-1842, representing another noisy
change in gh-1842.
No semantical changes.

* add comments
* move the transaction management code to a single place
* no semantical changes

There's an optimization in vy_range_rotate_mem() which makes it delete
the active in-memory tree instead of moving it to the frozen list
provided it's empty. However, since commit 8116f209 ("vinyl: pin
in-memory trees on tx prepare") an empty in-memory tree may be pinned by
an ongoing transaction, in which deleting it will result in use after
free in vy_tx_write().

Test is broken by design.

Pin each in-memory tree which is going to be modified by a transaction
on Engine::prepare, unpin it on commit or rollback. Pinned in-memory
trees can't be dumped until they are unpinned - dump/compaction task
constructors wait until pin_count drops to 0 before handing the task
over to a worker thread. Since the constructors rotate the in-memory
tree before waiting and new transaction can only go to active in-memory
trees, they won't wait forever, only until all transactions that were
started before the task was scheduled are over.

This is needed to insert statements into in-memory trees on tx prepare,
not on tx commit as per now.

Note, since vy_scheduler->checkpoint_lsn is only set after
wal_checkpoint() while we select the in-memory tree to insert a new
statement into in Engine::prepare, i.e. before writing to WAL, in order
to guarantee snapshot consistency (i.e. that no statements inserted
after WAL rotation will make it to the snapshot) we have to change the
condition triggering rotation of the in-memory tree upon insertion of a
statement from:

  mem->min_lsn <= checkpoint_lsn

to

  mem->snapshot_version != snapshot_version

(snapshot_version is increased on snapshot before wal_checkpoint())

Vinyl transaction manager does not allow a transaction to have lsn 0.
This is a pre-requisite for the patch for gh-1842 (vy_tx_write() rewrite).

Make struct recovery_journal re-usable and employ it during
final join, to ensure the engine has correct LSNs during
final join.

Ensure we properly set recovery_journal when bootstrapping
a replica from a remote master and reading master write ahead log.
This is necessary for Vinyl, which expects strictly monotonic transaction
signatures on commit at all times.

+ Travis CI
+ Telegram
+ Slack
+ Google Groups

Fixes #2261

Rewrite this test using TAP to avoid interference of test-run.

Fixes #1849

Moved to tarantool/doc repository.

Closes #1488

Fixes #2190

Handle event loop for every 0.1M of restored snapshot rows. Issue #2108

vinyl expects that entry->res contains a correct signature of the
transaction. We used to sloppily assign it to some non-zero signature
of the last committed transaction in the batch in case of success.
Vinyl expects an exact value, growing monotonically for each next
transaction.

Optimistically promote writer vclock with replica vclock before
write, in hope that the same row is never applied twice. To be
covered with test and addressed in a separate patch (gh-2283).