If 'box.cfg' fails with error, 'log.cfg' still gets updated: instead,
update 'log.cfg' after verifying 'box.cfg', and rollback if update of
'log.cfg' fails.

Closes #6086

box_api_cfg_set_log_{level, format} are part of dynamic_cfg (see
box/lua/load_cfg.lua) and are expected to throw exceptions (see
reload_cfg ib.).

Needed for #6086

On big instances core produces too much logs related to shapshotting,
which feels redudant: reduce snapshot verbosity.

Closes #6220

Make say_ratelimit_check emit warnings about suppressed messages only if
the correspoding log level is greater or equal then WARN.

Add say_crit_ratelimited and say_info_ratelimited macros for
convenience.

Needed for #6220

* memprof: add info about trace start to symtab
* memprof: group allocations on traces by traceno
* memprof: refactor location parsing
* test: separate memprof Lua API tests into subtests

Closes #5814

This patch introduces MAP to SQL. After this patch, all SQL operations
and built-in functions should work correctly with MAP values. However,
there is currently no way to create MAP values using only SQL tools.

Part of #4763

@TarantoolBot document
Title: Field type MAP in SQL

Properties of type MAP in SQL:
1) a value of type MAP can be implicitly and explicitly cast only to
ANY;
2) only a value of type ANY with primitive type MAP can be explicitly
cast to MAP;
3) a value of any other type cannot be implicitly cast to MAP;
4) a value of type MAP cannot participate in arithmetic, bitwise,
comparison, and concatination operations.

This patch introduces ARRAY to SQL. After this patch, all SQL operations
and built-in functions should work correctly with ARRAY values. However,
there is currently no way to create ARRAY values using only SQL tools.

Part of #4762

@TarantoolBot document
Title: Field type ARRAY in SQL

Properties of type ARRAY in SQL:
1) a value of type ARRAY can be implicitly and explicitly cast only
   to ANY;
2) only a value of type ANY with primitive type ARRAY can be explicitly
   cast to ARRAY;
3) a value of any other type cannot be implicitly cast to ARRAY;
4) a value of type ARRAY cannot participate in arithmetic, bitwise,
   comparison, and concatination operations.

This patch introduces the mem_snprintf() function, which writes the
string representation of a MEM to buf.

This patch removes quotes from the representation of UUID values in the
error description. This is because UUID values are printed without
quotes elsewhere.

After this commit only three workflow are run on pull request or push to
a developer branch:
 - luacheck
 - release
 - debug_coverage

To run all other tests, one should either name the branch `*-full-ci`
and push it to the main repository or set the 'full-ci' label on the
pull request.

It is also possible to disable all tests on push by naming branch as
`*-notest' or setting the 'notest' label on the pull request.

**Caveats**:
 - Unfortunately, currently it doesn't seem to be possible to run
   workflows automatically when a particular label is set - the best we
   can do is run workflows when *any* label is set. So labeling a PR
   that has the 'full-ci' label set will trigger all workflows!
 - For the same reason, removing the 'notest' label doesn't trigger ci.
   One has to synchronize the PR afterwards. We could trigger ci on the
   'unlabel' event, but this would trigger tests when any label is
   removed, not necessarily 'notest'. Since 'notest' is supposed to be
   used only by developers, who can sync the branch, this should be
   acceptable.

While we are at it:
 - Remove the check disabling certain workflow runs on forks - it's
   pointless, because forks don't have ci. Anyway, we don't bother
   disabling most of our workflows on forks, even those that we run on
   self-hosted machines, so that would only be consistent.
 - Remove the condition from the coverity workflow - coverity doesn't
   run on push or PR so it doesn't make any sense.
 - Remove the condition from the 'source' workflow. Instead trigger it
   only when a tag is pushed. This is needed to avoid showing it as a
   skipped workflow in PRs and commits.

Closes #6605

Line-by-line (mostly) migration of the net.box state machine
implementation from Lua to C. The C implementation uses the iostream
abstration, which will allow us to to easily support complex network
protocols under IPROTO in future.

Closes #6291

Currently,

 - socket.tcp_server sets AI_PASSIVE.
 - socket.tcp_connect sets no flags, but passes 'tcp' for protocol.
 - coio_connect sets AI_ADDRCONFIG|AI_PASSIVE|AI_NUMERICSERV.
 - evio_service sets AI_ADDRCONFIG|AI_PASSIVE.

This leads to different getaddrinfo results on some platforms (freebsd)
and, as a result, test breakages (net.box_connect_timeout_gh-2054) after
we switch net.box from socket.tcp_connect to coio_connect.

Let's use compatible flags:
 - AI_ADDRCONFIG for clients (coio_connect and tcp_connect).
   (AI_PASSIVE doesn't make sense for connect.)
   (AI_NUMERICSERV isn't really needed in our case.)
 - AI_ADDRCONFIG|AI_PASSIVE for servers (evio_service, tcp_server).

Let's also set ai_protocol to 'tcp' in both tcp_connect and tcp_server
for consistency, because both these functions are only supposed to work
with the tcp protocol, judging by their names.

It's too low-level. Use conn:_request instead.

While we are at it, let's explicitly check the error in
net.box_long-poll_input_gh-3400.test.lua to make it more
robust.

We will use iostream in net.box when we convert the state machine to C.
Rework netbox_communicate() so that it's easy to migrate to iostream.

xrow_decode_auth() expects the password to be set so omitting it while
preparing a request is incorrect. Net.box state machine (in Lua) sets
the password to an empty string if it's nil so the code handling NULL
password in netbox_encode_auth() is actually dead. Let's remove it.

The callback passed to the worker fiber (in create_transport())
references the connection object. Since a fiber is a GC root, it means
that the worker fiber pins the connection object. To avoid this, we use
a weak callback reference. To prevent the callback from being GC-ed
prematurely, we need to store a strong reference to it somewhere.
Currently, we have some GC magic in create_transport(): we store a
strong reference to the callback in the bound parameters of
transport.stop(). This works fine, but when we migrate the transport
implementation to C, we won't be able to override transport.stop() so
let's store a strong reference in the connection object instead.

While we are at it, let's drop create_transport method from net.box
module exports, because it's not used anywhere in Tarantool code or
tests, neither is it documented.

A GC callback must not yield.

Fixes commit 72adeda6 ("net.box:
implement connection closing without dropping requests");

Closes #6617

The callback isn't supposed to normally raise exceptions (it runs client
code in pcall). If something abnormal happens, like a memory allocation
error, better break the loop and stop the state machine.

Also, raise an exception if we failed to decode an IPROTO_EVENT packet -
this means that something is wrong with the other end and we better stop
the connection (this is what we do if we fail to decode other packets).

Currently, some errors raise exception (e.g. memory allocation, fiber is
cancelled) while others are handled by the state machine code. Let's
pass all errors in exceptions and drop error_sm. This simplifies the
state machine code a little bit.

We can implement it in Lua, because the transport invokes the callback
whenever the state changes. This will simplify conversion of the state
machine to C.

Pass protocol version and features to handshake callback along with
greeting. The fewer callbacks we have, the easiser it'll be to convert
the code to C.

While we are at it, add a missing comment for the event callback.

There's no point in using the callback for this. It'd only complicate
moving the state machine to C.

Not used since console support was dropped. Drop it to simplify
migration of the net.box state machine to C.

@TarantoolBot document
Title: Update the net.box state machine diagram

New diagram from the net.box source code:

```
initial -> auth -> fetch_schema <-> active

(any state, on error) -> error_reconnect -> auth -> ...
                                         \
                                          -> error
(any state, but 'error') -> closed
```

net.box console support was deprecated more than three years ago, in
commit bd06e32a ("netbox: deprecate
console support"). Let's drop it, because it'll greatly simply rewriting
the net.box state machine in C.

@TarantoolBot document
Title: Delete documentation entry for net.box console

net.box console support, which was deprecated in 1.10, was dropped.
Now, one has to use `require('console').connect(host, port)` instead
of `require('net.box').connect(host, port, {console = true})`.

establish_connection is used by console to check greeting: if the
protocol is 'Binary', it wraps the connected socket in a net.box
connection; if it's 'Lua console', it wraps the socket in a console
handler.

Presence of these methods complicates migration of the net.box state
machine to C. Also, it'll be difficult to support establish_connection
when we switch net.box to the iostream abstraction, because a greeting
should be received via iostream, not fd, probably after some
protocol-specific negoitiation (e.g. TLS), while iostream isn't (and
won't be) available in Lua and so can't be easily passed around from
establish_connection to Lua and then back to net.box state machine.

Since Lua console will always use plain sockets (it doesn't require
encryption as it's supposed to run on the local host), let's first try
to establish a net.box connection and if it fails because of unsupported
protocol, try to establish a Lua console connection. It means that the
socket will be connected twice for Lua console, which is suboptimal, but
it should be fine, because it's not a hot path.

* Fix frame traversal for __gc handler frames.

According to a huge amount of commit pushes by developers we should
cancel all outdated workflow runs (previously scheduled and not relevant
due to new changes) to make CI more efficient. GitHub Actions provides
the 'concurrency' feature [1] as a method of reaching that and this
patch introduces its using.

How does it work?

Basically, an update of a developer branch cancels the previously
scheduled workflow run for this branch. However, the 'master' branch,
release branch (1.10, 2.8, etc.), and tag workflow runs are never
canceled.

[1] https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#concurrency

Closes tarantool/tarantool-qa#100

Before this patch test build failed with following error:
```
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.0.sdk/usr/include/c++/v1/memory:2666:26: error: unexpected type name '_CompressedPair': expected expression
    struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
```

This patch seems to be fix this issue.
The root of the problem is in "trivia/util.h" module. It defines
alignas macros: `#define alignas(_n)
__attribute__((aligned(_n)))`. And it seems causes some issues in
stdlib internals. To fix this issue let's unconditionally include
stdalign.h for C++. According [1] this header should internally
define __alignas_is_defined macro.

[1] https://en.cppreference.com/w/cpp/language/alignas

Part of #6576

After this patch, all functions that take arguments of one of two or
more types have defined a default type, which is used when the argument
type cannot be determined.

Closes #6483

@TarantoolBot document
Title: Default types of SQL built-in functions

In case a function takes an argument of one of two or more types, this
function has defined the default type for this argument. This type is
used when the type of the argument cannot be determined, for example, in
the case of a bound variable.

Rules for determining default types as follows:
1) When there is only one possible type, it is default.
2) When possible types are INTEGER, DOUBLE or DECIMAL, DECIMAL is
   default.
3) When possible types are STRING or VARBINARY, STRING is default.
4) When possible data types are any other scalar data type, SCALAR is
   default.
5) Otherwise, there is no default type.

After this patch, all SQL built-in functions will work correctly with
DECIMAL values.

Closes #6355

coio_connect() returns a file descriptor so we need to
fix the check from != 0 to < 0.

Fixes commit ec937bee
("coio: check inet_pton result").

Reported by Coverity.

coio_accept, coio_read, coio_write, coio_writev used to handle spurious
wakeups correctly: if the timeout hasn't passed yet, they would simply
retry reading (or writing) and fall asleep once again if no data is
ready.

This behaviour changed in the following patches:
577a640a ("coio: pass fd to
coio_accept") and 4f84859d ("Introduce
iostream wrapper for socket I/O").

Now the functions timeout on the very first spurious wakeup.

Fix this and add the appropriate unit tests.

The tests in here use unix sockets. Should work in parallel fine
and not interfere.

The test sometimes failed the test cases
test_read_only_reason_synchro_no_uuid and
test_read_only_reason_election_has_leader_no_uuid.

Both relied on an instance being gone from 'replicaset' global
internal object in C once it is gone from _cluster. But it wasn't
true.

If an instance is not visible in _cluster, it could still be not
deleted from 'replicaset' because it is done only on WAL write
end. So this was a dirty read - the check about an id absent in
_cluster.

The more reliable way is to check that the replica is gone from
box.info.replication - it is built from this 'replicaset' object.

Closes #6621

Reported by Coverity.

While we are at it, let's also mark coio_fill_addrinfo static, because
it isn't used outside coio.c.

**pos is dereferenced before it is checked via *pos == end. This leads
to out of bounds access when *pos == end.

It got broken in 54be00b6
("error: use error_payload in Lua"). 2 symbols were dropped from
the exports but not from this test.

Follow-up #5568

The problem was that when we wanted to check that
the transaction rolled back after the timeout, we
called `fiber.sleep` on the local instance, while
the timeout for transaction counted on the remote
instance. Fix the text, so now we call `fiber.sleep`
on remote server, ensuring that timeout for transaction
expires.

Closes #6586

Previously, iproto could only open one socket for listening
only. This patch change this behaviour, now user can open
several listening sockets. Also in addition to ability to
pass uri as a number or string, as  previously, ability to
pass uri as a table of numbers or strings has been added.

Closes #3554

@TarantoolBot document
Title: multiple iproto listen sockets
Implement ability to open several listening sockets.
Implement ability to pass several listening uri as a table
of numbers or strings.
```lua
box.cfg { listen = {3301, 3302, 3303} }
box.cfg { listen = {"127.0.0.1:3301", "127.0.0.1:3302"} }
```