If xlog_flush() fails, box.snapshot() will still succeed, but
recovery from such an incomplete snapshot will fail. Fix it and
add the corresponding test case.

Update netbox.space objects in-place instead of re-creating them
on every schema change.

Closes #2401

* Add support of string.strip, string.lstrip, string.rstrip

Closes #2785

In 1.7 the join procedure consists of two phases: initial, during which
we send the last snapshot, and final, when we send xlogs written after
the snapshot. Between the two phases, the replica uuid is added to the
cluster table on the master, so by the time join is finished, the
replica should have received its id.

However, on 1.6 there's no final join phase, instead the master expects
the replica to receive xlogs upon subscription. As a result, the replica
doesn't receive its id until it sends the subscribe request.  This is
not expected by 1.7 clients - they fail with ER_UNKNOWN_REPLICA.

Fix this problem by making 1.7 replicas proceed to subscription and wait
until the id is received before completing bootstrap from 1.6 master.

Closes #2702

There was a bug in small garbage collection that resulted in tuple
leak in case box.snapshot() races with DML. The leak was indicated
by constantly growing box.slab.info().items_used. Update the small
library to fix it.

Closes #2842

This reverts commit 8b6cefd0.

This feature is so good to be pushed into 1.7. Sorry.

Improve usability.

Follow up 9297ec36 "chmod and chown control socket"

Fixes #2852.
Fixes #2849.

* Fix parsing in case of unexpected headers
* Fix duplicating headers in case of retransmitting responses

A workaround for #2836

Tomap() creates a lua table with both names and number indexes.
Each named field stored by its name AND by its index in a tuple.
For example, if a tuple is {'a', 'b', 'c'} and its format is
{'field1', 'field2'}, then t.field1 is the same as t[1], t.field2 is
the same as t[2].

Not named fields can be accessed only by their indexes. For the example
above 'c' can be accessed only as t[3].

Closes #2821

* Call box.cfg() instead of raising an error on the first access to box.XXX

Fixes #2559

Fix typos in types check in string module

Closes #2775

Check request fields on NULL before print.

Needed to remove monitoring fibers from shard and use only netbox
api to track, if a connection is closed or reopened.

Closes #2858

Closes #2779

luarocks make <rockspec> allows one to build a rock from local
directory.

In addition to the "rocks make" argument, one additional option is
needed in tarantoolctl: --chdir. This is because we need to build
inside the rock directory, but output the result to
<project_root>/.rocks.

Implements #2846

> src/box/txn.c:454:40: error: '_Alignof' applied to an expression is a GNU extension [-Werror,-Wgnu-alignof-expression]
>                 diag_set(OutOfMemory, sizeof(*svp) + alignof(*svp) - 1,
>                                                      ^

Do not try to be smart and guess allocation size using alignof.

> src/box/memtx_tree.c:391:11: error: comparison of unsigned enum expression < 0 is always false [-Werror,-Wtautological-compare]
>         if (type < 0 || type > ITER_GT) { /* Unsupported type */
>             ~~~~ ^ ~

> src/box/vinyl_index.c:184:29: error: comparison of unsigned enum expression < 0 is always false [-Werror,-Wtautological-compare]
>         if (type > ITER_GT || type < 0) {
>                               ~~~~ ^ ~

Move the check for illegal params (i.e. 'type < 0') to the box API.
In index callbacks, only check that the iterator type is supported
by the index.

Since we already have the index_create_iterator() method to create an
iterator, the API basically consists of two functions: iterator_next()
and iterator_delete(). While iterator_delete() is just a trivial wrapper
around iterator::free callback, iterator_next() is more than that: it
also checks schema version and invalidates the iterator in case there
was a DDL that affected the index. Previously, this was done only by the
box API, but the overhead of this check seems to be really negligible so
it is compelling to do it from the internal API so that an internal API
user doesn't need to care about DDL once he opened an iterator.

Needed for #2776

This virtual method was added to make use of the 'position' optimization
implemented in memtx. Since the optimization was removed recently, we
don't need it anymore.

The primary reason for these methods to be implemented differently
for memtx and vinyl was the 'position' optimization exploited by
the memtx engine: since selects from memtx do not yield, we could
use a preallocated iterator there.

Now, as the 'position' optimization became redundant and was
removed due to the switch to memory pools for iterator allocations,
the only idiosyncrasy left in the memtx implementation is the count()
optimization: count() falls back on size() for ITER_ALL. Since this
optimization consists of just a few lines of code, we don't really
need memtx_index_count() co-used by all memtx index implementations:
we can implement it in each memtx index separately.

That being said, let us:
 - implement generic versions of min(), max(), and count();
 - make vinyl, memtx, and sysview engines use generic versions of
   the above-mentioned methods if appropriate;
 - Remove memtx_index.[hc]

As a side-effect, this patch enables min(), max(), and count() in
the sysview engine, but that is not bad considering that this engine
implements general-purpose iterator for its indexes.

We don't need index_position() optimization any more as all iterators
are allocated from memory pools. Remove it and merge iterator allocation
and initialization procedures.

Needed for #2776

Currently, index iterator allocation and initialization are separated.
This is done in order to speed up iterator creation when the caller
does not yield: there's 'position' method, which returns a preallocated
iterator and can be used instead of costly 'alloc'; the iterator
returned by this method needs to be initialized just like an iterator
allocated normally, via 'alloc'. This looks ugly, because 'position'
is engine-dependent, e.g. it can't be used in case of vinyl, because
vinyl yields internally.

Let's allocate all index iterators from memory pools. Since allocation
from a memory pool is very cheap, this will allow us to get rid of the
above-mentioned 'position' hack and simplify the iterator API.

Currently, index iterator allocation and initialization are separated.
This is done in order to speed up iterator creation when the caller
does not yield: there's 'position' method, which returns a preallocated
iterator and can be used instead of costly 'alloc'; the iterator
returned by this method needs to be initialized just like an iterator
allocated normally, via 'alloc'. This looks ugly, because 'position'
is engine-dependent, e.g. it can't be used in case of vinyl, because
vinyl yields internally.

We can get rid of the above-mentioned 'position' hack by simply using a
mempool for allocating iterators. To do that, we need to access engine
from index, so this patch adds a reference to struct engine to struct
index.

Box functions were initially written as C wrappers around internal C++
API so they used try/catch to propagate errors. Now we can rewrite them
without try/catch, as we have C API for DML/DQL.

Current internal tnx API is not particularly user-friendly in regards to
error handling: if txn_begin_stmt(), txn_commit_stmt(), or txn_commit()
fails, the txn state is undefined and the caller must rollback manually.
To make the API easier to use, let's oblige these function rollback
automatically in case of failure.

Needed for #2776

Apart from executing a request, process_rw() may also:
 - replace nil with a sequence value;
 - rebind update to the primary key.

Let's fold this logic in the internal space API so that it can
be easily reused by SQL.

Note, request_rebind_to_primary_key() must not fail, because
it is called after the request was successfully executed,
which implies that the engine performed all necessary checks,
so replace exceptions with asserts there.

Needed for #2776

Fixes #2845

Needed for #2776

Needed for #2776

Needed for #2776

Preparation for converting txn to C.

This will help removing exceptions from txn methods.

Needed for #2776

To convert engine and space infrastructure to C, we need to make txn
usable from C code. The only reason why we can't convert txn.cc to C
right now is triggers: they are set from alter.cc and may throw
exceptions. To handle this, let's make trigger_run() catch all
exceptions and return an error code instead. For C++ code, introduce
trigger_run_xc() which calls trigger_run() under the hood and throws
the exception suppressed by it.

Needed for #2776

Preparation for converting engine implementation to C.

Needed for #2776

 - Add a return code to both space_foreach() and its callback so that
   the caller can use it to propagate errors instead of throwing
   exceptions.
 - Make space_foreach() exception-free.
 - Export the function to C.

Preparation for converting engine implementation to C.

Needed for #2776

Preparation for converting engine implementation to C.

This will help removing exceptions from engine callbacks.

Needed for #2776

vy_set_timeout() and vy_set_max_tuple_size() are not supposed to fail.
Remove the return code and diag_raise() in the engine wrapper.