Part of https://github.com/tarantool/tarantool-ee/issues/564

NO_DOC=The documentation request is to be added as part of Tarantool
       Enterprise Edition patchset.
NO_CHANGELOG=see NO_DOC
NO_TEST=To be tested in Tarantool Enterprise Edition.

The new 'supervised' failover mode uses an external failover agent to
make decisions regarding leadership in a replicaset. This is a feature
of Tarantool Enterprise Edition.

This commit adds a new `replication.failover` value `supervised`, adds
corresponding instance startup code and necessary configuration
validation.

The most interesting part is how to start all the instances in RO, but
if the replicaset is not bootstrapped yet, start one instance in RW to
perform the replicaset bootstrap. See comments in applier/box_cfg.lua
for details.

Part of https://github.com/tarantool/tarantool-ee/issues/564

NO_DOC=The documentation request is to be added as part of Tarantool
       Enterprise Edition patchset.
NO_CHANGELOG=see NO_DOC
NO_TEST=The overall logic of this mode is to be tested in Tarantool
        Enterprise Edition.

It is not convenient that test_downgrade_from_more_recent_version breaks
if we create tag for new version and do not add next version to the
downgrade versions list. If the version is released we should add it to
the list anyway but it is not matter of this test.

Follow up #9182

NO_DOC=internal
NO_CHANGELOG=internal

In this case we don't have knowledge how to downgrade correctly.

Close #9182

NO_DOC=bugfix

mp_compare_decimal_any_number erroneously assumed that any float or
double from which a decimal can't be created is either infinite or NaN.
This is not true. Any float greater than 1e38 can't fit into our decimal
representation. When such a float got compared to a decimal, an
assertion fired, which was wrong. Luckily, on release build the
comparison was correct. Only the assertion is wrong. Fix it.

Closes #8472

NO_DOC=bugfix

NO_CHANGELOG=see the previous commit

@TarantoolBot document
Title: C API update - added support for key part sort order.

Looks like the `box_key_part_def_t` type isn't documented, but
`BOX_KEY_PART_DEF_SORT_ORDER` bit field was added to its `flags`
member. The possible values are:

`BOX_KEY_PART_DEF_SORT_ORDER_ASC`: default sort order.
`BOX_KEY_PART_DEF_SORT_ORDER_DESC`: reversed sort order.

* Add ability to specify sort_order when creating a key def via
  lua key_def API.
* Update key_def.totable to also emit the sort order.

NO_CHANGELOG=see the previous commit

@TarantoolBot document
Title: key_def API update - added support for key part sort order.

The part sort order is specified the same way as in index creation:

```
key_def.new({{1, 'unsigned', sort_order = 'desc'}})
```

The sort order is now taken into account in comparison functions.

Affected documentation: [link](https://www.tarantool.io/en/doc/latest/reference/reference_lua/key_def/)

The `sort_order` parameter was introduced earlier but had no effect
until now. Now it allows to specify a sort (iteration) order for
each key part.

The parameter is only applicable to ordered indexes, so any value
except 'undef' for the `sort_order` is disallowed for all indexes
except TREE. The 'undef' value of the `sort_order` field of the
`key_part_def` is translated to 'asc' on `key_part` creation.

In order to make the key def aware if its index is unordered, the
signature of `key_def_new` has been changed: the `for_func_index`
parameter has been moved to the new `flags` parameter and
`is_unordered` flag has been introduced.

Alternative iterator names has been introduced (which are aliases
to regular iterators): box.index.FORWARD_[INCLUSIVE/EXCLUSIVE],
box.index.REVERSE_[INCLUSIVE/EXCLUSIVE].

By the way fixed the `key_hint_stub` overload name, which supposed
to be called `tuple_hint_stub`.

`tuple_hint` and `key_hint` template declarations has been changed
because of the checkpatch diagnostics.

Closes #5529

@TarantoolBot document
Title: Now it's possible to specify sort order of each index part.

Sort order specifies the way indexes iterate over tuples with
different fields in the same part. It can be either ascending
(which is the case by default) and descending.

Tuples with different ascending parts are sorted in indexes from
lesser to greater, whereas tuples with different descending parts
are sorted in the opposte order: from greater to lesser.

Given example:

```lua
box.cfg{}

s = box.schema.create_space('tester')
pk = s:create_index('pk', {parts = {
  {1, 'unsigned', sort_order = 'desc'},
  {2, 'unsigned', sort_order = 'asc'},
  {3, 'unsigned', sort_order = 'desc'},
}})

s:insert({1, 1, 1})
s:insert({1, 1, 2})
s:insert({1, 2, 1})
s:insert({1, 2, 2})
s:insert({2, 1, 1})
s:insert({2, 1, 2})
s:insert({2, 2, 1})
s:insert({2, 2, 2})
s:insert({3, 1, 1})
s:insert({3, 1, 2})
s:insert({3, 2, 1})
s:insert({3, 2, 2})
```

In this case field 1 and 3 are descending, whereas field 2 is
ascending. So `s:select()` will return this result:

```yaml
---
- [3, 1, 2]
- [3, 1, 1]
- [3, 2, 2]
- [3, 2, 1]
- [2, 1, 2]
- [2, 1, 1]
- [2, 2, 2]
- [2, 2, 1]
- [1, 1, 2]
- [1, 1, 1]
- [1, 2, 2]
- [1, 2, 1]
...
```

Beware, that when using other sort order than 'asc' for any field
'GE', 'GT', 'LE' and 'LT' iterator lose their meaning and specify
'forward inclusive', 'forward exclusive', 'reverse inclusive' and
'reverse exclusive' iteration direction respectively. Given example
above, `s:select({2}, {iterator = 'GT'})` will return this:

```yaml
---
- [1, 1, 2]
- [1, 1, 1]
- [1, 2, 2]
- [1, 2, 1]
...
```

And `s:select({1}, {iterator = 'LT'})` will give us:

```yaml
---
- [2, 2, 1]
- [2, 2, 2]
- [2, 1, 1]
- [2, 1, 2]
- [3, 2, 1]
- [3, 2, 2]
- [3, 1, 1]
- [3, 1, 2]
...
```

In order to be more clear alternative iterator aliases can be used:
'FORWARD_INCLUSIVE', 'FORWARD_EXCLUSIVE', 'REVERSE_INCLUSIVE',
'REVERSE_EXCLUSIVE':

```
> s:select({1}, {iterator = 'REVERSE_EXCLUSIVE'})
---
- [2, 2, 1]
- [2, 2, 2]
- [2, 1, 1]
- [2, 1, 2]
- [3, 2, 1]
- [3, 2, 2]
- [3, 1, 1]
- [3, 1, 2]
...
```

The tests are required to perform safe refactoring of comparators.

Covered comparison functions are:
- `tuple_compare_sequential`: all valid `is_nullable` and
  `has_optional_parts` combinations.
- `tuple_compare_with_key_sequential`: all valid `is_nullable` and
  `has_optional_parts` combinations.
- `tuple_compare_slowpath`: all valid `is_nullable` and
  `has_optional_parts` combinations. `has_json_paths` and
  `is_multikey` options are not covered since they don't affect
  the comparison logic.
- `tuple_compare_with_key_slowpath`: all valid `is_nullable` and
  `has_optional_parts` combinations. See the point above about
  other options.
- `key_compare`: both `is_nullable` option variants.

NO_DOC=new tests
NO_CHANGELOG=new tests

Currently the test is written in C. To simplify the following test
update it's required to switch the test to the C++ language.

NO_DOC=refactoring
NO_CHANGELOG=refactoring

After commit 9b2b3e58 ("box: apply dynamic cfg even if option
value is unchanged"), running box.cfg{} with any parameters logs
the values of those options, even if the option value has not changed.
This is quite awkward for config as it gives a lot of options to
box.cfg{}, although many of them may have the old value. This patch
causes box.cfg{} to log only those options whose values have changed.

Closes #9195

NO_DOC=No need.
NO_CHANGELOG=No need since the mentioned commit was not released yet.

New event named 'tarantool.trigger.on_change' is called when any event
is modified (trigger.set or trigger.del). All the handlers are called with
one argument - name of the modified event. Returned value of each handler
is ignored. Handlers are fired after the event is changed (the event
contains inserted trigger, if any, and does not contain deleted one, if
any). All thrown errors are logged with error level and do not stop
execution of triggers.

Closes #8664

NO_CHANGELOG=later
NO_DOC=later

Module trigger should be cleaned up after each test. It didn't cause any
troubles because each test used a unique name of event for its purposes.
Let's remove all registered triggers after each test for the sake of
maintainability.

Also, move the tests to a separate server instance - currently tests use
tarantool which is a test runner, so it may affect other tests during a
competitive launch.

NO_CHANGELOG=test
NO_DOC=test

The patch moves space triggers to trigger registry. Triggers for each
space are stored in two events: event, associated with space by name,
and event, associated with space by id. For example, if we have a space
named 'test' with id = 512, its on_replace trigger will be stored in
'box.space[512].on_replace' and 'box.space.test.on_replace' events. When
space triggers are fired, triggers, associated by id, are called first.
Since the triggers are moved to trigger registry, space trigger API is
slightly changed - it is populated with optional third argument (trigger
name) and its key-value variant.

One of the main advantages of using trigger registry is setting triggers
before box.cfg{}, but it would not be used for before_replace triggers
since they can change tuples on recovery, and most of the time the user
does not need it. To solve this problem, we decided to disable space
triggers on recovery. However, ability to change tuples during recovery
is necessary (for example, to be able to override engine on replica),
that is why the patch introduces recovery triggers for spaces - they are
fired only on recovery. Similar to regular triggers, recovery triggers
for each space are stored in two events. Recovery version of
before_replace triggers for space 'test' with id 512 are stored in
'box.space[512].before_recovery_replace' and
'box.space.test.before_recovery_replace'. Triggers on_replace have their
recovery version as well. Recovery triggers receive 2 arguments in
addition to its regular versions - xrow header and xrow body of type
MsgPack object. Both MsgPacks are maps with integer keys.

Since regular and recovery triggers cannot be used at the same time, we
store them at the same pointer in space - it refers to recovery triggers
on recovery and to regular ones when recovery is over. To update the
triggers, helper space_on_final_recovery_complete is used. However, it
is not fired after bootstrap of a new master, and triggers of all
spaces, created during bootstrap, would not be updated - a new helper
space_on_bootstrap_complete is introduced.

There is another, more serious, breakage of backward compatibility. All
triggers were stored in the space - it means that after the space is
renamed it still has all its triggers, and when the space is dropped, all
the triggers are removed. This patch moves triggers of space to trigger
registry, which is just a key-value storage of triggers. That is why space
do not own its triggers anymore - it just takes triggers from trigger
registry. So, when the space is renamed, all the triggers, associated by
id, are still associated with the space, but not the triggers associated
by name - the space will fire triggers from an event, associated with a
space by its new name.

In order to relieve the pain of broken compatibility, all the triggers,
which are set with an old API, are set to an event, associated by id.
Also, when one sets a space trigger with an old API, it is set to both
regular version of trigger and a recovery one if recovery has not been
finished yet. For example, s:before_replace(foo) will set a trigger to
both 'box.space[512].before_replace' and
'box.space[512].before_recovery_replace' events before recovery is
finished and to the first event only after recovery.

Along the way, fixed an assertion that failed when before_replace
changed new tuple on recovery from snapshot.

Also, message of error ER_BEFORE_REPLACE_RET is changed.
The type of value, returned by before_replace triggers was in the
message before, but new triggers are called with a func_apapter, which
does not allow to get a type of returned value, so the type was removed
from the message.

Part of #8657
Closes #8859
Closes #9127

NO_CHANGELOG=later
NO_DOC=later

Object xrow_header is a parsed MsgPack header of xrow packet. Since we
are going to pass header and body of request in recovery triggers, we
need to pass a pointer to the header of binary packet. Let's add such
pointer to xrow_header object.

Part of #8859

NO_CHANGELOG=internal
NO_DOC=internal

Since before_replace triggers have different semantics for returned nil
value and no return values, we need to distinguish between these cases.
That is why func_adapter_is_null does not return true when no more
values left anymore - new method func_adapter_is_empty is introduced
for this purpose.

Along the way, remove description of func_adapter_lua_is_bool function -
it is copied description of is_null function, which was here by mistake.

Part of #8657

NO_CHANGELOG=internal
NO_DOC=internal

The commit adds msgpack object to func_adapter. It is required to pass
xrow object to recovery triggers.

Part of #8859

NO_CHANGELOG=internal
NO_DOC=internal

Before this patch privileges for space, function and sequence alone
were disabled. Only permission for universe could be granted. It was
done because there wasn't a way to grant or revoke a privilege when
subjecting object hasn't been created yet.

This patch allows grants and revokes for objects that will be created
after the applier. These actions will be postponed and executed via
on_commit trigger after the object is registered in the according system
space of box.space._space/_func/_sequence.

Now permission can be granted to space/function/sequence from within the
config.

Part of #8967

NO_DOC=documentation request will be filed manually for the whole
       credentials

Before this patch reload_success_case() didn't allow to pass arguments
to verify_2() in the same way as to verify(). Now they can be passed
via opts.verify_args_2.

Part of #8967

NO_DOC=test helper upgrade
NO_CHANGELOG=see NO_DOC
NO_TEST=see NO_DOC

This patch sets the aforementioned option to new. This is a breaking
change that makes the behaviour of the stored C functions called locally
and remotely via iproto consistent.

Closes #4799
Relates to #8576

NO_DOC=see previous commit

With this option enabled (new), the multiresults returned by a stored C
function via iproto aren't wrapped in the additional msgpack array (old).

Due to new behaviour some renames are performed:
* `port_c_dump_msgpack()` -> `port_c_dump_msgpack_wrapped()`, since this
  is dump format with additional msgpack array encoded.
* `port_c_dump_msgpack16()` -> `port_c_dump_msgpack()`, since this
  format is now the default new format of a msgpack dump.

The behaviour of the C port msgpack dumping depends on the
`c_func_iproto_multireturn` option:
* uses `port_c_dump_msgpack()` if set to true (new),
* uses `port_c_dump_msgpack_wrapped()` otherwise (old).

Needed for #4799

@TarantoolBot document
Title: Document `c_func_iproto_multireturn` compat option

Please create a documentation page for the new compat option:
https://tarantool.io/compat/c_func_iproto_multireturn

In the new behaviour, the multiresults returned by a stored C function
via iproto aren't wrapped in the additional msgpack array (old).

```
tarantool> compat.c_func_iproto_multireturn = 'old'
---
...

tarantool> net_box.connect(box.cfg.listen):call('myclib.cfunc')
---
- [true, -1]
...

tarantool> compat.c_func_iproto_multireturn = 'new'
---
...

tarantool> net_box.connect(box.cfg.listen):call('myclib.cfunc')
---
- true
- -1
...

```

The new behaviour is consistent with the local call of the function
via `box.func`:

```
tarantool> box.func['myclib.cfunc']:call()
---
- true
- -1
...

```

Assume you have a stored C function that returns values like the
following:

```c
char *position = mp_encode_bool(buffer, true);
box_return_mp(ctx, buffer, position);
/* ... */
position = mp_encode_int(buffer, -1);
box_return_mp(ctx, buffer, position);
```

If you want to preserve the format of the returned array for your C
functions, when the `c_func_iproto_multireturn` option is set to "new",
you should add the additional wrapping, like the following:

```c
char *position = mp_encode_array(buffer_with_results, n_results);
position = mp_encode_bool(position, true);
/* ... */
position = mp_encode_int(position, -1);
box_return_mp(ctx, buffer_with_results, position);
```

The amount of `box_return_mp()` calls indicates the number of values to
be returned.

Also, you should update its usage via `box.func` if there is any.

luarocks version updated to version 3.9.2

Closes #6597

NO_DOC=The engine has been updated, the functionality has not changed
NO_TEST=see NO_DOC

Before this patch if one called `vinyl`, `sql`, `gc` and `memory`
functions from box.info() instance crashed. It's interesting that
`replication_anon` functions worked ok.
This patch fixes that crashes.

Closes #9173

NO_DOC=bugfix

Part of https://github.com/tarantool/tarantool-ee/issues/564

NO_DOC=The documentation request is to be added as part of Tarantool
       Enterprise Edition patchset.
NO_CHANGELOG=see NO_DOC
NO_TEST=To be tested in Tarantool Enterprise Edition.

The option enables a built-in failover coordinator script, which reads a
configuration from a file (pointed by --config option) or from etcd,
connects to all the instances, polls them for their status and performs
automatic actions to ensure that there is an active leader in each
replicaset (if possible).

The failover coordinator code is part of Tarantool Enterprise Edition.

Part of https://github.com/tarantool/tarantool-ee/issues/564

NO_DOC=The documentation request is to be added as part of Tarantool
       Enterprise Edition patchset.
NO_CHANGELOG=see NO_DOC
NO_TEST=To be tested in Tarantool Enterprise Edition.

Our split-brain detection machinery relies among other things on all
nodes tracking the synchro queue confirmed lsn. This tracking was only
added together with the split-brain detection. Only the synchro queue
owner tracked the confirmed lsn before.

This means that after an upgrade all the replicas remember the latest
confirmed lsn as 0, and any PROMOTE/DEMOTE request from the queue owner
is treated as a split brain.

Let's fix this and only enable split-brain detection on the replica set
once the schema version is updated. Thanks to the synchro queue freeze
on restart, this can only happen after a new PROMOTE or DEMOTE entry is
written by one of the nodes, and thus the correct confirmed lsn
is propagated with this PROMOTE/DEMOTE to all the cluster members.

Closes #8996

NO_DOC=bugfix

This patch introduces a new CLI option: --force-recovery.

Closes #8876

@TarantoolBot document
Title: --force-recovery CLI option

The --force-recovery CLI option is another way to set the box.cfg{}
force_recovery option. The priority of this option is higher than the
priority of the TT_FORCE_RECOVERY environment variable, but less than
the priority of explicitly setting the box.cfg{} force_recovery option.

The goal of this patch is to make the xlog writer API less confusing.
It does the following changes:

 - Rename xlog_rename to xlog_materialize. The function strips the
   .inprogress suffix from an xlog file name. Usually it's called after
   the xlog was sealed (by writing the EOF marker) and closed but it may
   also be called before xlog_close in case the xlog file is going to be
   appended to (used in WAL).

 - Make xlog_sync private. It's called by xlog_close so there's no point
   in calling it manually. Make xlog_close fail if it fails to sync the
   file.

 - Make xlog_close flush the buffer so that the caller doesn't need to
   call xlog_flush manually before closing an xlog file.

 - Drop the reuse_fd argument of xlog_close. Instead, introduce a new
   function xlog_close_reuse_fd that works exactly like xlog_close
   except it doesn't close the fd and returns it in the out argument.

 - Introduce xlog_discard. It's supposed to be called on an incomplete
   xlog file to close its fd and unlink it.

Rework all the places where we write xlog files in accordance with the
new API. Note about memtx snapshot writer: use xlog_materialize and
xlog_discard instead of coio_rename and coio_unlink.

The new API (especially the xlog_discard helper) facilitates
introduction of thorough (secure) file deletion because it significantly
reduces the number of places in the code where xlog files are deleted.

Needed for tarantool/tarantool-ee#540

NO_DOC=refactoring
NO_TEST=refactoring
NO_CHANGELOG=refactoring

Proposed ASAN implementation of region allocator does not support double
reservation for the sake of simplicity. Every reservation is supposed to
be followed by one or more allocations.

This restiction does not work well with mpstream currently. The issue is
mpstream_init/mpstream_reserve do reservation of size 0. For example In
case of region slab of min order is reserved (a chunk of memory of page
size currently). If the first data we want to write to mpstream is
larger then the reservation done then we make reservation again.

Let's get rid of this reservation at the beginning as it is suboptimal
behaviour. Moreover let's get rid of mpstream_reset as mpstream_init
is lightweight and we can create a new mpstream instead of reusing
exiting.

Also while we at it avoid allocation of 0 size in mpstream_flush as it
is done in mpstream_reserve_slow (see 3.0.0-alpha3-19-g8159347d0 "misc:
avoid allocations of size 0 for region" for details).

NO_TEST=internal
NO_CHANGELOG=internal
NO_DOC=internal

When a replica is restarted, it doesn't immediately switch to the
'follow' state. First it needs to sync. Let's wait for the 'follow'
state a bit to fix the following failure:

NO_WRAP
[039] replication-luatest/gh_9049_schema_downgrade_t>                 [ fail ]
[039] Test failed! Output from reject file /tmp/t/rejects/replication-luatest/gh_9049_schema_downgrade.reject:
[039] Tarantool version is 3.0.0-alpha3-18-g6892907bad9d
[039] TAP version 13
[039] 1..1
[039] # Started on Thu Sep 21 13:55:09 2023
[039] # Starting group: replication-luatest.gh_9049_schema_downgrade
[039] not ok 1  replication-luatest.gh_9049_schema_downgrade.test_schema_downgrade
[039] #   ...st/replication-luatest/gh_9049_schema_downgrade_test.lua:33: expected: "follow"
[039] #   actual: "sync"
[039] #   stack traceback:
[039] #         ...st/replication-luatest/gh_9049_schema_downgrade_test.lua:31: in function 'replication-luatest.gh_9049_schema_downgrade.test_schema_downgrade'
[039] #         ...
[039] #         [C]: in function 'xpcall'
[039] #   artifacts:
[039] #   replica -> /tmp/t/039_replication-luatest/artifacts/replica-AgoXGWUXxvnc
[039] #   master -> /tmp/t/039_replication-luatest/artifacts/master-ZUTtyXyAX9YF
[039] # Ran 1 tests in 1.768 seconds, 0 succeeded, 1 failed
NO_WRAP

Fixes commit 71de4b2c ("box: fix schema downgrade replication").

NO_DOC=test fix
NO_CHANGELOG=test fix

The new option is backed by `box.cfg.auth_retries`. It is available only
in Enterprise Edition builds.

Needed for tarantool/tarantool-ee#541

NO_DOC=will be added to Enterprise Edition
NO_CHANGELOG=will be added to Enterprise Edition

Before this patch credentials applier used to just skip if Tarantool
was in Read Only mode. Now it starts a fiber that waits for instance
to be switched to Read Write mode and then applies in the background.

Part of #8967

NO_DOC=documentation request will be filed manually for the whole
       credentials

If MP_ERROR map contains two MP_ERROR_STACK keys, then the second call to
`error_set_prev(effect, cur)' will crash, because `effect' is NULL, but
`err == NULL' is false, because it is assigned on the first iteration.
This patch raises an error if more than one MP_ERROR_STACK key is present.

NO_DOC=bugfix

Closes #9136

Wraps multistatement DDL functions into begin/commit block if no
transaction is active.

The functions are:
- `box.schema.space.drop`
- `box.schema.index.create`
- `box.schema.index.drop`
- `box.schema.index.alter`
- `box.schema.sequence.drop`
- `box.schema.func.drop`
- `box.schema.user.create`
- `box.schema.user.drop`
- `box.schema.role.drop`

Added tests for atomicity of each transactioned function except
the `box.schema.role.drop`, which is implicitly tested with the
`box.schema.user.drop` test, and the `box.schema.index.drop`,
which is impossible to test in this flavor without using error
injection.

Updated the tests modified in tarantool/tarantool#8947, because
the space drop is atomic now.

Closes #4348

NO_DOC=bugfix

Sequences can only be attached to integer fields of a space. The
corresponding check is done in both schema.lua and alter.cc. The
problem is that in order to make the index alter transactional,
we have to perform the `_index` space tuple replace before the
existed sequence is unattached from the space (because the index
alter may be yielding). And the check existing in the alter.cc
won't allow us to do that in some cases.

Since the check already exists in `box.schema.index.alter`, it's
decided to drop it from the `_index` `on_replace` trigger.

The downside of the solution is that uncareful manual altering the
index can silently put the space into an inconsistent condition:
the next insert into the space can either fail or silently succeed
whereas it's not supposed operation for the space. Example:

```lua
box.cfg{}
s = box.schema.space.create('s')
pk = s:create_index('pk', {parts = {{1, 'unsigned'}}, sequence = true})

-- Manual altering the index without dropping the sequence.
box.space._index:update({s.id, pk.id}, {{'=', 6, {{0, 'string'}}}})

-- This will fail: passed integer (from sequence) in string field.
s:insert({box.NULL})

-- Manual altering the index without dropping the sequence again.
box.space._index:update({s.id, pk.id}, {{'=', 6, {{0, 'scalar'}}}})

-- This will succeed: passed integer (from sequence) in scalar field.
-- Though it shouldn't have been done at all: one should not pass
-- NULL in the field which is indexed by the primary key.
s:insert({box.NULL})
```

NO_DOC=no visible changes
NO_TEST=no visible changes
NO_CHANGELOG=no visible changes

The commit populates submodule session with an event for each public
trigger - they will be used for user-defined triggers. Old triggers are
not removed because they are used for internal purposes - audit from EE
uses them, for instance. Also, the commit introduces a test for all
triggers that use old API. It checks only session triggers now - all the
other triggers will be included there after they will be moved to the
trigger registry.

In order to have an opportunity to move user-defined triggers to trigger
registry, the commit introduces helper luaT_event_reset_trigger that
supports two different ways to set triggers - key-value API and positional
API. The first one is a new API that allows to set or delete trigger only
by name. The second API is implemented for the sake of backward
compatibility - it mimics behavior of function lbox_trigger_reset, which
was used to modify triggers, but sets the triggers to event from trigger
registry instead of separate trigger list. Also, positional API allows
to pass a name as the third argument - in this case the function will
set or delete trigger by passed name - the first argument is a new
trigger (or nil, if the function is called to delete a trigger), the
second argument will be ignored in this case.

The new helper supports not only functions - any callable object can be
used as a trigger.

Part of #6484
Part of #8657

NO_CHANGELOG=later
NO_DOC=later

Sql fuzzer uses box module depending on event subsystem, which was
not initialized by mistake. It didn't cause any problems because box
does not use events yet, but it will use them when triggers will be
moved to the trigger registry, so let's initialize event in sql fuzzer.

Part of #8657

NO_CHANGELOG=test
NO_DOC=test

Boolean type is required by box.session.on_auth triggers.

Part of #8657

NO_CHANGELOG=internal
NO_DOC=internal

With this patch, mp_check sets diag with detailed information about
the MsgPack decoding error. The diag includes the error reason, which is
appended to the error message, and the data offset, which is stored in
an error payload field. Possible error reasons are: truncated input,
junk after input, illegal code, invalid extension. In case of truncated
input, the error also includes the trunc_count payload field, which is
set to the number of missing MsgPack values. Failing to decode a MsgPack
extension adds two payload fields, ext_type and ext_len, and also an
error cause, which is set by the extension decoder. For all extensions
except the error extension, the error cause is just "cannot unpack FOO".
For the error extension, it includes a detailed cause pointing to the
error in the MsgPack data stored in the extension.

Currently, the mp_check error is reported only by the Lua msgapck
decoder while other mp_check users (e.g. xrow decoder) override it.
We may improve on this in future.

Examples:

tarantool> require('msgpack').decode('\x94\xc0')
---
- error: Invalid MsgPack - truncated input
...

tarantool> box.error.last():unpack()
---
- offset: 2
  code: 20
  base_type: ClientError
  type: ClientError
  trunc_count: 3
  message: Invalid MsgPack - truncated input
  trace:
  - file: ./src/box/msgpack.c
    line: 151
...

tarantool> require('msgpack').decode(string.char(
         >   130,  39, 170, 114, 101, 116, 117, 114, 110,  32,  46,
         >    46,  46,  33, 145, 199,  74,   3, 129,   0, 145, 134,
         >     0, 171,  67, 108, 105, 101, 110, 116,  69, 114, 114,
         >   111, 114,   1, 170,  99, 111, 110, 102, 105, 103,  46,
         >   108, 117,  97,   2, 211,   0,   0,   0,   0,   0,   0,
         >     0, 201,   3, 173,  85, 110, 107, 110, 111, 119, 110,
         >    32, 101, 114, 114, 111, 114,   4, 211,   0,   0,   0,
         >     0,   0,   0,   0,   0,   5, 211,   0,   0,   0,   0,
         >     0,   0,   0,   0))
---
- error: Invalid MsgPack - invalid extension
...

tarantool> box.error.last():unpack()
---
- code: 20
  base_type: ClientError
  prev: Invalid MsgPack - cannot unpack error
  message: Invalid MsgPack - invalid extension
  ext_len: 74
  ext_type: 3
  trace:
  - file: ./src/box/msgpack.c
    line: 161
  type: ClientError
  offset: 18
...

tarantool> box.error.last().prev:unpack()
---
- code: 20
  base_type: ClientError
  type: ClientError
  prev: Invalid MsgPack - MP_ERROR_LINE value must be MP_UINT
  message: Invalid MsgPack - cannot unpack error
  trace:
  - file: ./src/box/msgpack.c
    line: 126
...

tarantool> box.error.last().prev.prev:unpack()
---
- offset: 30
  code: 20
  base_type: ClientError
  type: ClientError
  message: Invalid MsgPack - MP_ERROR_LINE value must be MP_UINT
  trace:
  - file: ./src/box/mp_error.cc
    line: 350
...

Closes #7968

NO_DOC=error reporting improvement

The patch adds a fuzzing test for IPROTO decoding function
xrow_decode_error().

Follows up #8921
Follows up #9098

NO_DOC=testing
NO_CHANGELOG=testing