Now vinyl's rollback to TX savepoint doesn't work in case when one
TX has several statements modifying the same key.

A simple example is presented in gh ticket 2589.

Fix it.

Add a big test that compares vinyl with memtx in case of many
failing (catched with pcall) statements done in a transaction.

Fixes #2589

Now if a TX (in vinyl) changes the same key again, it uses
previously created struct txv and updates the tuple in it.
Therefore the change is not added to the transaction log; instead,
the old entry in the log is updated.

At the same time, the order of TX log is important, especially when
there are several indexes in a vinyl space: tx_prepare traverses
TX log, determines the beginning of a tarantool statement (that
could consist of several vinyl statements) and behave with several
conjuncted txvs as a whole.

Fix it by leaving old txv and always creating new txv.

Fixes #2577

- don't reference the upserted tuple twice in vy_tx_set(..)
- handle txv allocaion error properly in vy_tx_et(..)

The return value of txv_new was not checked.

Instead introduce vy_run_env_enable_coio(), which starts reader threads,
and make vy_run_iterator automatically switch to coio if reader threads
are running. With this patch, vy_read_iterator doesn't need a pointer to
vy_env to add a run as a source, only vy_run_env.

While we are at it, cleanup vy_conf a bit.

Needed for #1906

vy_run_write_page() doesn't take a reference to last_stmt, because it
assumes that the write iterator guarantees it won't be deleted until
'next' is called again. The iterator does pin a statement if it is read
from a run file - see vy_write_iterator_set_tuple() - however there's a
case when the last returned statement can go away under us. This will
happen if the iterator is used for major compaction and the last source
statement is a DELETE. In this case the iterator will unreference the
last statement it returned to the caller, take a reference to the DELETE
instead, but won't return the DELETE - see vy_write_iterator_next(). As
a result, the caller, i.e. vy_run_write_page(), will hit use-after-free
on an attempt to read last_stmt.

To fix this bug, let's make vy_run_write_page() take a reference to
last_stmt as it used to before the write iterator was reworked. A test
case will be added later, after all iterator-related issues have been
fixed.

Closes #2578

Iconv is a library to convert a sequence of characters in one
character encoding to a sequence of characters in another character
encoding. Example below converts utf-16 big endian string into utf-8
string:

    convertor = require('iconv').new('UTF-16BE', 'UTF-8')
    converted_string = convertor(source_string)

Closes #2587

vy_task_dump_new() deletes empty in-memory trees right away, but
doesn't increment vy_index->mem_list_version, which may result in
a read iterator crash accessing a deleted vy_mem.

Now open MP sort is used for any size of an array.
For small arrays it's an overkill and even can cause overhead
due to thread pool creation.

Invoke open MP sort only for big arrays and use old good
single-thread qsort for small arrays.

Fix #2431

Print original uri as is if it doesn't contain sensitive
information.

Closes #2292

Currently, quota (and some global stats) are adjusted in
vy_index_commit_upsert(), vy_tx_prepare(), and vy_tx_commit(),
which entails dependency of vy_index and tx_manager on vy_env.
Let's move this code to the upper level, i.e. to vy_prepare()
and vy_commit().

Needed for #1906

Remove box.info.vinyl().performance.{tx_rlb,tx_conflict}. Instead add
'tx' section to box.info.vinyl() with the following counters:

 - 'active': number of active transactions
 - 'commit': number of committed transactions
 - 'rollback': number of rolled back transactions
 - 'conflict': number of transactions aborted on conflict

Apart from improving vinyl statistics, this patch also pursues one more
goal: removing dependency of vy_tx and tx_manager on vy_env, which is
needed to move them to a separate source file.

Needed for #1662 #1906

It belongs there, really.

Currently, during local recovery, an index is added to the
scheduler from vy_index_recover(), which makes this function
depend on index->env->scheduler. Let's postpone addition to
vy_index_commit_create() as we do when vinyl is online.

Needed for #1906

Needed to remove dependency of vy_index on struct txv.

Needed for #1906

Before this patch, the new space, created by alter specification,
would be put into space cache only after successful WAL write.

This behaviour is not linearizable: on a replica, the WAL is
played sequentially, and the order of events could differ from the
master.

Besides, it could crash, as demonstrated in gh-2074 test case.

Since we use a cascading rollback for all transactions on WAL
write error, it's OK to put a space into space cache
before WAL write, so that the new transactions apply to the new
space.

This patch does exactly that.

All subsequent requests are executed against the new space.

This patch also removes on_replace trigger in the old space, since
all checks against the new tuple format are performed using the new
space.

Fixes #2074.

 Do not leak input buffer references on an incorrect packet.

 Before this patch, in case of incorrect packet, in->rpos was never
 advanced, creating an eternal request and blocked input buffer.

 A follow up on gh-1654.

closes gh-2576

* update comments
* add a test case for altering a primary key on the fly
* rename AddIndex to CreateIndex
* factor out common code into a function

MoveIndex operation is used to move an existing index from the old space
to the new one. Semantically it's a no-op.

RebuildIndex is introduced for case when essential index properties are
changed, so it is necessary to drop the old index and create a new one in
its place in the new space.

AlterSpaceOp::prepare() is removed: all checks are moved to
on_replace trigger in _index system space from it.
All checks are done before any alter operation is created.

Necessary for gh-2074 and gh-1796.

Move the check which decides on an alter strategy whenever
a row in _index space is changed, from AlterSpaceOp::preapre()
to on_replace trigger on _index space.

The check chooses between two options: a heavy-weight index rebuild,
invoked when index definition, such as key parts, is changed, vs.
lightweight modify, invoked when index name or minor options are
modified..

Before this patch, index alteration creates a pair of operations
(DropIndex + AddIndex) in all cases, but later
replaces two operations with one at AlterSpaceOp::prepare() phase.

This is bad by several reasons:

- it's done while traversing of a linked list of operations,
  and it changes the list being traversed.

- an order in the list of operations is required for this
to work: drop must precede add.

- needless allocation and deallocation of operations makes the logic
  unnecessarily complex.

Necessary for gh-1796.

Always first create the primary key index in a space. Put
the primary key key def first in the array of key_defs, passed
into tuple_format_new(). This is necessary for gh-1796.

Assert that we can't create a space with secondary key but no primary.

Now drop primary index checks are made in alter triggers after
new space creation. Such an implementation leads to temporary
creation of a space with invalid index set. Fix it and check
the index set before space_new call.

Non destructive swap_index_def function sould be used because memtx_tree
stores a pointer to an index_def used while tree creation. Fixed #2570

Commit dbfd515f ("vinyl: fix crash if snapshot is called while dump
is in progress") introduced a bug that can result in statements inserted
after WAL checkpoint being included in a snapshot. This happens, because
vy_begin_checkpoint() doesn't force rotation of in-memory trees anymore:
it bumps checkpoint_generation, but doesn't touch scheduler->generation,
which is used to trigger in-memory tree rotation.

To fix this issue, this patch zaps scheduler->checkpoint_generation and
makes vy_begin_checkpoint() bump scheduler->generation directly as it
used to. To guarantee dump consistency (the issued fixed by commit
dbfd515f), scheduler->dump_generation is introduced - it defines the
generation of in-memory data that are currently being dumped. The
scheduler won't start dumping newer trees until all trees whose
generation equals dump_generation have been dumped. The counter is only
bumped by the scheduler itself when all old in-memory trees have been
dumped. Together, this guarantees that each dump contains data of the
same generation, i.e. is consistent.

While we are at it, let's also remove vy_scheduler->dump_fifo, the list
of all in-memory trees sorted in the chronological order. The scheduler
uses it to keep track of the oldest in-memory tree, which is needed to
invoke lsregion_gc(). However, since we do not remove indexes from the
dump_heap, as we used to not so long ago, we can use the heap for this.
The only problem is indexes that are currently being dumped are moved
off the top of the heap, but we can detect this case by maintaining a
counter of dump tasks in progress: if dump_task_count is > 0 when a dump
task is completed, we must not call lsregion_gc() irrespective of the
generation of the index at the top of the heap. A good thing about
ridding of vy_scheduler->dump_fifo is that it is a step forward towards
making vy_index independent of vy_scheduler so that it can be moved to a
separate source file.

Closes #2541
Needed for #1906

vy_index->generation equals to the generation of the oldest in-memory
tree, which can be looked up efficiently as vy_index->sealed list is
sorted by generation so let's zap it and add vy_index_generation()
function instead.

Needed for #1906

Including index.h just for the sake of iterator_type, as we do in
vy_run.h and vy_mem.h, is a bit of overkill. Let's move its definition
to a separate source file, iterator_type.h.

 - Replace vy_range->index with key_def.
 - Replace vy_range_iterator->index with vy_range_tree_t.

Needed for #1906

The compact_heap, used by the scheduler to schedule range compaction,
contains all ranges except those that are currently being compacted.
Since the appropriate vy_index object is required to schedule a range
compaction, we have to store a pointer to the index a range belongs to
in vy_range->index. This makes it impossible to move vy_range struct and
its implementation to a separate source file.

To address this, let's rework the scheduler as follows:

 - Make compact_heap store indexes, not ranges. An index is prioritized
   by the greatest compact_priority among its ranges.

 - Add a heap of ranges to each index, prioritized by compact_priority.
   A range is removed from the heap while it's being compacted.

 - Do not remove indexes from dump_heap or compact_heap when a task is
   scheduled (otherwise we could only schedule one compaction per
   index). Instead just update the index position in the heaps.

Needed for #1906

Advancing replica->gc on every status update is inefficient as gc can
only be invoked when we move to the next xlog file. Currently, it's
acceptable, because status is only updated once per second, but there's
no guarantee that it won't be updated say every millisecond in future,
in which case advancing replica->gc on every status update may become
too costly.

So introduce a trigger invoked every time an xlog is closed by
recover_remaining_wals() and use it in relay to send a special gc
message.

ipc_cond_wait() always returns 0, so the body of the loop waiting for
the endpoint to be ready for destruction is only invoked once.

To make sure there is no status message pending in the tx pipe,
relay_cbus_detach() waits on relay->status_cond before proceeding to
relay destruction. The status_cond is signaled by the status message
completion routine (relay_status_update()) handled by cbus on the
relay's side. The problem is by the time we call relay_cbus_detach(),
the cbus loop has been stopped (see relay_subscribe_f()), i.e. there's
no one to process the message that is supposed to signal status_cond.
That means, if there happens to be a status message en route when the
relay is stopped, the relay thread will hang forever.

To fix this issue, let's introduce a new helper function, cbus_flush(),
which blocks the caller until all cbus messages queued on a pipe have
been processed, and use it in relay_cbus_detach() to wait for in-flight
status messages to complete. Apart from source and destination pipes,
this new function takes a callback to be used for processing incoming
cbus messages, so it can be used even if the loop that is supposed to
invoke cbus_process() stopped.

 - Fold in wal dir scan. It's pretty easy to detect if we need to rescan
   wal dir - we do iff the current wal is closed (if it isn't, we need
   to recover it first), so there's no point in keeping it apart.

 - Close the last recovered wal on eof. We don't close it to avoid
   rereading it in case recover_remaining_wals() is called again before
   a new wal is added to wal dir. We can detect this case by checking if
   the signature of the last wal stored in wal dir has increased after
   rescanning the dir.

 - Don't abort recovery and print 'xlog is deleted under our feet'
   message if current wal file is removed. This is pointless, really -
   it's OK to remove an open file in Unix. Besides, the check for
   deleted file is only relevant if wal dir has been rescanned, which is
   only done when we proceed to the next wal, i.e. it doesn't really
   detect anything.

A good side effect of this rework is that now we can invoke garbage
collector right from recovery_close_log().