Support multi-part keys. Allow key duplicate
compaction. Reduce storage cost, encode metadata,
do not store msgpack (except value part).
Reconstruct tuple on read using index schema.

[replication]

JOIN support temporary put to not working
condition: there is no way to access possibly
deleted space schema during the operation
for a tuple reconstruction
(multi-thread).

recreate space key_def during join; enable join

sophia: make every operation asynchronous

sophia: fix join cursor and tests

sophia: implement delayed update operation

sophia: make delete write-only

implement Handler::executeReplace

sophia: merge fixes

make upsert operation an engine specific

sophia: make update logic common to memtx

sophia-integration: switch to Sophia v1.2.3; implement upsert

sophia: add half_commit mode support

This mode disables conflict resolution for
'prepared' transactions and solves the issue with
concurrent write-write conflicts during wal write/yield.

sophia: do not allocate tuple during replace or update; refactoring

sophia: extend and reorganize test suite

sophia: implement box.sophia()

sophia: #681: support or produce error on space::alter

sophia: extend recover tests

sophia: add separate iterator tests

box: enable per-engine select

    * add executeSelect() into engine handler API
    * add MemtxIndex; move preallocated m_position from Index to MemtxIndex
    * remove it->close()
    * remove IteratorGuard class

    note: Sysview and Sophia engines yet share the same select code in
    engine::executeSelect() (which does iterator alloc-free)

box: remove close call from box_iterator_free()

Implement rtti-like scheme to export C++ type information to FFI.

Extract Exception::clear(), Exception::move(), fiber()->exception
into struct diag methods. This refactoring makes desired logic
to be more clear.

Don't try to rename an .inprogrss file in recovery_finalize(): if
recovery_finalize() can't open it, then xdir_scan() must have
failed to open it as well, then the file can't end up in the index
in the first place.

Don't try to re-read a file 3 times (good number, eh), since this
looks like chasing a ghost. If the original cause for these
lines of code (lost) is still relevant, then a different fix will
be necessary.

The original code was apparently trying to cope with a potential
race condition between local hot standby/replication relay and WAL
writer, where WAL writer thread first creates a new WAL file, and
only aft that closes the previous one, while local hot standby
scans the directory, and then reads all files which it finds in
the directory.

Apparently, the author of the code believed that some data in the
file may not be visible to the reader process after it was written
by the writer process, and the reader could skip this data and
switch to the next file. The switch can not be postponed, since,
when reading the file, it's impossible to know whether it's an old
corrupted file or a new one.

Remove the code, since, according to Linux man page:

POSIX requires that a read(2) which can be proved to occur after a
write() has returned returns the new data. Note that not all
filesystems are POSIX conforming.

POSIX says:

Writes can be serialized with respect to other reads and writes.
If a read of file data can be proven (by any means) to occur after
a write() of the data, it must reflect that write(), even if the
calls are made by differen processes. A similar requirement
applies to multiple write operations to t same file position. This
is needed to guarantee the propagation of data fr write() calls to
subsequent read() calls. This requirement is particularly
significant for networked file systems, where some caching schemes
violate these semantics.

Note that this is specified in terms of read() and write(). The
XSI extensions readv() and writev() also obey these semantics. A
new "high-performance" write analog that did not follow these
serialization requirements would also be permitted by this
wording. This volume of IEEE 1003.1-2001 is also silent about any
effects of application-level caching (such as that done by stdio).

Reorder the events in wal_opt_rotate(): first close the old file,
and only then open a new one.

Fix a bug in replication that didn't take into account wal_dir_rescan_delay.
This fix revealed a number of serious races in recovery_follow_f,
which will be addressed separately.

Rewrite replication to use cooperative I/O.
Propagate replication exceptions to the main thread.
Introduce a function which stats a thread with a running
event machine in it.

Fix a few bugs related to destruction of resources allocated in a
non-main thread.

Remove replication_prefork() and all the code related to pushing
a socket into another process.
Add debug asserts to slab cache, to ensure it's used from a single
thread only.

Add a test case.
Rename fiber.test to fiber_stress.test
Change cxception propagation so that exception is fiber-local,
not thread local.
Added exception propagation to fiber_join().

Rename fiber_zombificate() to fiber_recycle().
Don't double-initialize same members of the fibers.
Introduce a function which contains common initialization
of fiber_new() and fiber_recycle().
Use a common naming scheme for lists of dead, alive and ready
fibers in a cord.

Remove explicit fiber call stack from the cord.

Fix backtrace() to work correclty with an optimized (-O2) build.

Explicitly mark places which are unsafe for cancel.

Everything is cancellable. In fiber_cancel() use fiber_wakeup()
instead of a direct call. This make cancel safe with
regards to wakeup() and timeouts: i.e. it's safe to cancel
a fiber which is waiting on a timeout or is about to get
scheduled.

Avoid an unnecessary interlocked instruction or pipe write
in fiber_wakeup(), it's always called from the same cord
as the one to which the event loop belongs.

Use ev_feed_event() with EV_CUSTOM instead.

Unit test coio_stat.

Cleanup unit tests a bit: merge unit.h and test.h, which
would duplicate each other.

Fix a bug in trigger_atexit.test, which would not clean up after
itself.

libcore is a thick a thick bundle with almost everything.
Rename it to libserver.

Extract the minimal server core with fibers & exceptions into libcore.

Add a prototype unit test for fibers.

Fix obvious coding bugs in cord_cojoin/cord_join().

Remove unnecessary constants & arguments.
Keep an eye on the include dependencies becoming more messy.
Clear the O_NONBLOCK flag in the join thread, which
uses non-blocking API.
Suspend I/O in the main thread event loop for the
duration of replication join/subscribe.

Use cached user credentials for global access checks and store
them in a separate fiber key.

This fixes gh-617 and speeds up privilege checks.

@todo: we need to add a linked list of all user sessions
to the user cache, as well as all user setuid functions.
These lists could be used to update privilege cache,
get/update per-user statistics, disconnect sessions
of a dropped user.

Other changes:

 * Saving/re-throwing original exception caused cord to terminate

This patch removes `session` and `lua_storage` fields from struct fiber.
A new API for fiber-local variables is now used for this purpose.
This change solves dependency problems between session and fiber modules.

Make status() a method.
Update the docs.

This patch explicitly saves Exception to a thread-local variable inside
struct cord on tnt_raise(). This variable can be used to safetly
re-throw last exception from any place (not only from catch() block).
This technique requires exception to be thrown and catched by pointers.
tnt_raise macros was rewritten and all 'catch (Exception &)' blocks were
substituted with 'catch (Exception *e)'.

This patch also adds a new feature to box.raise() function.
When called without arguments box.raise() re-throws last exception (if
any).

These changes needed to implement proper handlings of exception for FFI
calls.

Implement cord names.
Log cord names in the server log.
Try to make find_path() valgrind-clean (the bug, however,
is in glibc).

Introduce a structure to represent a thread with an event
loop in it.

Do not require a working event loop in say() or wal_opt_sync().