Laze rotations

close #353

CMakeLists.txt

@@ -77,6 +77,7 @@ if (BOOST_REDIS_MAIN_PROJECT)
     test
     json
     endian
+    compat
   )
 
   foreach(dep IN LISTS deps)

README.md

@@ -87,9 +87,9 @@ them are:
 * [Client-side caching](https://redis.io/docs/manual/client-side-caching/).
 
 The connection class supports server pushes by means of the
-`connection::async_receive` function, which can be
+`connection::async_receive2` function, which can be
 called in the same connection that is being used to execute commands.
-The coroutine below shows how to use it:
+The coroutine below shows how to use it
 
 
 ```cpp
@@ -99,26 +99,25 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
-   generic_response resp;
+   flat_tree resp;
    conn->set_receive_response(resp);
 
    // Loop while reconnection is enabled
    while (conn->will_reconnect()) {
 
       // Reconnect to channels.
-      co_await conn->async_exec(req, ignore);
+      co_await conn->async_exec(req);
 
       // Loop reading Redis pushes.
-      for (;;) {
-         error_code ec;
-         co_await conn->async_receive(resp, net::redirect_error(net::use_awaitable, ec));
+      for (error_code ec;;) {
+         co_await conn->async_receive2(resp, redirect_error(ec));
          if (ec)
             break; // Connection lost, break so we can reconnect to channels.
 
          // Use the response resp in some way and then clear it.
          ...
 
-         consume_one(resp);
+         resp.clear();
       }
    }
 }
@@ -126,4 +125,4 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 
 ## Further reading
 
-Full documentation is [here](https://www.boost.org/doc/libs/master/libs/redis/index.html).
+Full documentation is [here](https://www.boost.org/doc/libs/master/libs/redis/index.html).

doc/modules/ROOT/nav.adoc

@@ -3,6 +3,7 @@
 * xref:cancellation.adoc[]
 * xref:serialization.adoc[]
 * xref:logging.adoc[]
+* xref:sentinel.adoc[]
 * xref:benchmarks.adoc[]
 * xref:comparison.adoc[]
 * xref:examples.adoc[]

doc/modules/ROOT/pages/changelog.adoc

@@ -7,6 +7,146 @@
 
 = Changelog
 
+== Boost 1.90
+
+
+* (Pull request https://github.com/boostorg/redis/pull/310[310])
+  Improves the per-operation support in `async_exec()`. Requests can now
+  be cancelled at any point, and cancellations don't interfere with other
+  requests anyhow. In previous versions, a cancellation could cause
+  `async_run()` to be cancelled, making cancellations unpredictable.
+* (Issue https://github.com/boostorg/redis/issues/226[226])
+  Added support for the `asio::cancel_after` and `asio::cancel_at`
+  completion tokens in `async_exec()` and `async_run()`.
+* (Issue https://github.com/boostorg/redis/issues/319[319])
+  Added support for per-operation cancellation in `async_run()`.
+* (Pull request https://github.com/boostorg/redis/pull/329[329]
+  and https://github.com/boostorg/redis/pull/334[334])
+  The `cancel_on_connection_lost` and `cancel_if_not_connected`
+  flags in `request::config` have been deprecated, and will be removed
+  in subsequent releases. To limit the time span that `async_exec`
+  might take, use `asio::cancel_after`, instead.
+  `cancel_on_connection_lost` default has been changed to `false`.
+  This shouldn't cause much impact, since `cancel_on_connection_lost`
+  is not a reliable way to limit the time span that `async_exec` might take.
+* (Pull request https://github.com/boostorg/redis/pull/321[321])
+  Calling `cancel` with `operation::resolve`, `operation::connect`,
+  `operation::ssl_handshake`, `operation::reconnection` and
+  `operation::health_check` is now deprecated.
+  These enumerators will be removed in subsequent releases.
+  Users should employ `cancel(operation::run)`, instead.
+* (Issue github.com/boostorg/redis/issues/302[302] and
+  pull request https://github.com/boostorg/redis/pull/303[303])
+  Added support for custom setup requests using `config::setup`
+  and `config::use_setup`. When setting these fields, users can
+  replace the library-generated `HELLO` request by any other arbitrary request.
+  This request is executed every time a new physical connection with the server
+  is established. This feature can be used to interact with systems that don't
+  support `HELLO`, to handle authentication and to connect to replicas.
+* (Pull request https://github.com/boostorg/redis/pull/305[305])
+  `request::config::hello_with_priority` and `request::has_hello_priority()` have
+  been deprecated and will be removed in subsequent releases.
+  This flag is not well specified and should only be used by the library.
+  If you need to execute a request before any other, use `config::setup`, instead.
+* (Issue https://github.com/boostorg/redis/issues/296[296])
+  Valkey long-term support: we guarantee Valkey compatibility
+  starting with this release. Previous releases may also work,
+  but have not been tested with this database system.
+* (Issue https://github.com/boostorg/redis/issues/341[341])
+  Adds a `request::append()` function, to concatenate request objects.
+* (Issue https://github.com/boostorg/redis/issues/104[104])
+  The health checker algorithm has been redesigned to avoid
+  false positives under heavy loads. `PING` commands are now
+  only issued when the connection is idle, instead of periodically.
+* (Pull request https://github.com/boostorg/redis/pull/283[283])
+  Added `config::read_buffer_append_size`, which allows to control
+  the expansion of the connection's read buffer.
+* (Pull request https://github.com/boostorg/redis/pull/311[311])
+  Added `usage::bytes_rotated`, which measures data copying when
+  reading and parsing data from the server.
+* (Issue https://github.com/boostorg/redis/issues/298[298])
+  Added support for authenticating users with an empty password
+  but a non-default username.
+* (Issue https://github.com/boostorg/redis/issues/318[318])
+  Fixed a number of race conditions in the `cancel()` function
+  of `connection` and `basic_connection` that could cause
+  cancellations to be ignored.
+* (Issue https://github.com/boostorg/redis/issues/290[290])
+  Fixed a problem that could cause an error during `HELLO`
+  to make subsequent `HELLO` attempts during reconnection to fail.
+* (Issue https://github.com/boostorg/redis/issues/297[297])
+  Errors during `HELLO` are now correctly logged.
+* (Issue https://github.com/boostorg/redis/issues/287[287])
+  Fixed a bug causing an exception to be thrown when parsing
+  a response that contains an intermediate error into a `generic_response`.
+
+
+== Boost 1.89
+
+* (Pull request https://github.com/boostorg/redis/pull/256[256],
+   https://github.com/boostorg/redis/pull/266[266] and
+   https://github.com/boostorg/redis/pull/273[273])
+  The following members in `connection` and `basic_connection` are now deprecated
+  and will be removed in subsequent releases:
+  * `next_layer()` and `next_layer_type`: there is no reason to access the underlying stream object directly.
+    Connection member functions should be used, instead.
+  * `get_ssl_context()`: SSL contexts should never be modified after an `asio::ssl::stream`
+    object has been created from them. Properties should be set before passing the context
+    to the constructor. There is no reason to access the SSL context after that.
+  * `reset_stream()`: connection internals have been refactored to reset the SSL stream
+    automatically when required. This function is now a no-op.
+  * The `async_run()` overload taking no parameters: use the `async_run`
+    overload taking a `config` object explicitly, instead.
+* (Issue https://github.com/boostorg/redis/issues/213[213])
+  The logging interface has been re-written:
+  * Logging can now be customized by passing a function object
+    to the `logger` constructor. This allows integration with
+    third-party logging libraries, like spdlog.
+    This new logging interface is public and will be maintained long-term.
+  * The old, unstable interface consisting of `logger::on_xxx` functions has been removed.
+  * `connection` and `basic_connection` constructors now accept a `logger` object.
+    This is now the preferred way to configure logging.
+    The `async_run()` overload taking a `logger` object is now deprecated, and will
+    be removed in subsequent releases.
+  * `config::log_prefix` is now deprecated, and will
+    be removed in subsequent releases. Users can achieve the same effect
+    by passing a custom logging function to the `logger` constructor.
+  * The default logging function, which prints to `stderr`,
+    is now based on `printf` and is thus thread-safe.
+    The old function used `std::cerr` and could result to interleaved
+    output in multi-threaded programs.
+  * The default log level is now `logger::level::info`,
+    down from `logger::level::debug`. This results in less verbose output by default.
+* (Issue https://github.com/boostorg/redis/issues/272[272])
+  Added support for connecting to Redis using UNIX domain sockets.
+  This feature can be accessed using `config::unix_socket`.
+* (Issue https://github.com/boostorg/redis/issues/255[255])
+  Fixed an issue that caused `async_run` to complete when a connection
+  establishment error is encountered, even if `config::reconnect_wait_interval`
+  specified reconnection.
+* (Issue https://github.com/boostorg/redis/issues/265[265])
+  `connection::async_exec` now uses `ignore` as the default response,
+  rather than having no default response. This matches
+  `basic_connection::async_exec` behavior.
+* (Issue https://github.com/boostorg/redis/issues/260[260])
+  Fixed a memory corruption affecting the logger's prefix
+  configured in `config::log_prefix`.
+* (Pull request https://github.com/boostorg/redis/pull/254[254])
+  Fixed some warnings regarding unused variables, name shadowing
+  and narrowing conversions.
+* (Issue https://github.com/boostorg/redis/issues/252[252])
+  Fixed a bug that causes reconnection to ignore the reconnection
+  wait time configured in `config::reconnect_wait_interval`.
+* (Issue https://github.com/boostorg/redis/issues/238[238])
+  Fixed a bug introduced in Boost 1.88 that caused `response<T>` to
+  not compile for some integral types.
+* (Issue https://github.com/boostorg/redis/issues/247[247])
+  The documentation has been modernized, and a more complete
+  reference section has been added.
+* Part of the internals have been refactored to allow for better
+  testing and reduce compile times.
+
+
 == Boost 1.88
 
 * (Issue https://github.com/boostorg/redis/issues/233[233])

doc/modules/ROOT/pages/examples.adoc

@@ -15,7 +15,7 @@ The examples below show how to use the features discussed throughout this docume
 * {site-url}/example/cpp20_containers.cpp[cpp20_containers.cpp]: Shows how to send and receive STL containers and how to use transactions.
 * {site-url}/example/cpp20_json.cpp[cpp20_json.cpp]: Shows how to serialize types using Boost.Json.
 * {site-url}/example/cpp20_protobuf.cpp[cpp20_protobuf.cpp]: Shows how to serialize types using protobuf.
-* {site-url}/example/cpp20_resolve_with_sentinel.cpp[cpp20_resolve_with_sentinel.cpp]: Shows how to resolve a master address using sentinels.
+* {site-url}/example/cpp20_sentinel.cpp[cpp20_sentinel.cpp]: Shows how to use the library with a Sentinel deployment.
 * {site-url}/example/cpp20_subscriber.cpp[cpp20_subscriber.cpp]: Shows how to implement pubsub with reconnection re-subscription.
 * {site-url}/example/cpp20_echo_server.cpp[cpp20_echo_server.cpp]: A simple TCP echo server.
 * {site-url}/example/cpp20_chat_room.cpp[cpp20_chat_room.cpp]: A command line chat built on Redis pubsub.

doc/modules/ROOT/pages/index.adoc

@@ -97,9 +97,9 @@ them are:
 * https://redis.io/docs/manual/client-side-caching/[Client-side caching].
 
 The connection class supports server pushes by means of the
-xref:reference:boost/redis/basic_connection/async_receive.adoc[`connection::async_receive`] function, which can be
+xref:reference:boost/redis/basic_connection/async_receive.adoc[`connection::async_receive2`] function, which can be
 called in the same connection that is being used to execute commands.
-The coroutine below shows how to use it:
+The coroutine below shows how to use it
 
 
 [source,cpp]
@@ -110,26 +110,25 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
-   generic_response resp;
+   flat_tree resp;
    conn->set_receive_response(resp);
 
    // Loop while reconnection is enabled
    while (conn->will_reconnect()) {
 
       // Reconnect to channels.
-      co_await conn->async_exec(req, ignore);
+      co_await conn->async_exec(req);
 
       // Loop reading Redis pushes.
-      for (;;) {
-         error_code ec;
-         co_await conn->async_receive(resp, net::redirect_error(net::use_awaitable, ec));
+      for (error_code ec;;) {
+         co_await conn->async_receive2(resp, redirect_error(ec));
          if (ec)
             break; // Connection lost, break so we can reconnect to channels.
 
-         // Use the response resp in some way and then clear it.
+         // Use the response here and then clear it.
          ...
 
-         consume_one(resp);
+         resp.clear();
       }
    }
 }

doc/modules/ROOT/pages/reference.adoc

@@ -25,8 +25,12 @@ xref:reference:boost/redis/basic_connection.adoc[`basic_connection`]
 
 xref:reference:boost/redis/address.adoc[`address`]
 
+xref:reference:boost/redis/role.adoc[`role`]
+
 xref:reference:boost/redis/config.adoc[`config`]
 
+xref:reference:boost/redis/sentinel_config.adoc[`sentinel_config`]
+
 xref:reference:boost/redis/error.adoc[`error`]
 
 xref:reference:boost/redis/logger.adoc[`logger`]
@@ -51,6 +55,8 @@ xref:reference:boost/redis/response.adoc[`response`]
 
 xref:reference:boost/redis/generic_response.adoc[`generic_response`]
 
+xref:reference:boost/redis/generic_flat_response.adoc[`generic_flat_response`]
+
 xref:reference:boost/redis/consume_one-08.adoc[`consume_one`]
 
 
@@ -66,25 +72,33 @@ xref:reference:boost/redis/adapter/result.adoc[`adapter::result`]
 xref:reference:boost/redis/any_adapter.adoc[`any_adapter`]
 
 |
-xref:reference:boost/redis/resp3/basic_node.adoc[`basic_node`]
+xref:reference:boost/redis/resp3/basic_node.adoc[`resp3::basic_node`]
 
-xref:reference:boost/redis/resp3/node.adoc[`node`]
+xref:reference:boost/redis/resp3/node.adoc[`resp3::node`]
 
-xref:reference:boost/redis/resp3/node_view.adoc[`node_view`]
+xref:reference:boost/redis/resp3/node_view.adoc[`resp3::node_view`]
+
+xref:reference:boost/redis/resp3/basic_tree.adoc[`resp3::basic_tree`]
+
+xref:reference:boost/redis/resp3/tree.adoc[`resp3::tree`]
+
+xref:reference:boost/redis/resp3/view_tree.adoc[`resp3::view_tree`]
+
+xref:reference:boost/redis/resp3/flat_tree.adoc[`resp3::flat_tree`]
 
 xref:reference:boost/redis/resp3/boost_redis_to_bulk-08.adoc[`boost_redis_to_bulk`]
 
-xref:reference:boost/redis/resp3/type.adoc[`type`]
+xref:reference:boost/redis/resp3/type.adoc[`resp3::type`]
 
-xref:reference:boost/redis/resp3/is_aggregate.adoc[`is_aggregate`]
+xref:reference:boost/redis/resp3/is_aggregate.adoc[`resp3::is_aggregate`]
 
 
 |
 
 xref:reference:boost/redis/adapter/adapt2.adoc[`adapter::adapt2`]
 
-xref:reference:boost/redis/resp3/parser.adoc[`parser`]
+xref:reference:boost/redis/resp3/parser.adoc[`resp3::parser`]
 
-xref:reference:boost/redis/resp3/parse.adoc[`parse`]
+xref:reference:boost/redis/resp3/parse.adoc[`resp3::parse`]
 
 |===

doc/modules/ROOT/pages/requests_responses.adoc

@@ -278,7 +278,8 @@ struct basic_node {
 ----
 
 Any response to a Redis command can be parsed into a
-xref:reference:boost/redis/generic_response.adoc[boost::redis::generic_response].
+xref:reference:boost/redis/generic_response.adoc[boost::redis::generic_response]
+and its counterpart xref:reference:boost/redis/generic_flat_response.adoc[boost::redis::generic_flat_response].
 The vector can be seen as a pre-order view of the response tree.
 Using it is not different than using other types:
 
@@ -292,7 +293,7 @@ co_await conn->async_exec(req, resp);
 For example, suppose we want to retrieve a hash data structure
 from Redis with `HGETALL`, some of the options are
 
-* `boost::redis::generic_response`: always works.
+* `boost::redis::generic_response` and `boost::redis::generic_flat_response`: always works.
 * `std::vector<std::string>`: efficient and flat, all elements as string.
 * `std::map<std::string, std::string>`: efficient if you need the data as a `std::map`.
 * `std::map<U, V>`: efficient if you are storing serialized data. Avoids temporaries and requires `boost_redis_from_bulk` for `U` and `V`.

doc/modules/ROOT/pages/sentinel.adoc

@@ -0,0 +1,152 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+= Sentinel
+
+Boost.Redis supports Redis Sentinel deployments. Sentinel handling
+in `connection` is built-in: xref:reference:boost/redis/basic_connection/async_run-04.adoc[`async_run`]
+automatically connects to Sentinels, resolves the master's address, and connects to the master.
+
+Configuration is done using xref:reference:boost/redis/sentinel_config.adoc[`config::sentinel`]:
+
+[source,cpp]
+----
+config cfg;
+
+// To enable Sentinel, set this field to a non-empty list
+// of (hostname, port) pairs where Sentinels are listening
+cfg.sentinel.addresses = {
+    {"sentinel1.example.com", "26379"},
+    {"sentinel2.example.com", "26379"},
+    {"sentinel3.example.com", "26379"},
+};
+
+// Set master_name to the identifier that you configured
+// in the "sentinel monitor" statement of your sentinel.conf file
+cfg.sentinel.master_name = "mymaster";
+----
+
+Once set, the connection object can be used normally. See our
+our {site-url}/example/cpp20_sentinel.cpp[Sentinel example]
+for a full program.
+
+== Connecting to replicas
+
+By default, the library connects to the Redis master.
+You can connect to one of its replicas by using
+xref:reference:boost/redis/sentinel_config/server_role.adoc[`config::sentinel::server_role`].
+This can be used to balance load, if all your commands read data from
+the server and never write to it. The particular replica will be chosen randomly.
+
+[source,cpp]
+----
+config cfg;
+
+// Set up Sentinel
+cfg.sentinel.addresses = {
+    {"sentinel1.example.com", "26379"},
+    {"sentinel2.example.com", "26379"},
+    {"sentinel3.example.com", "26379"},
+};
+cfg.sentinel.master_name = "mymaster";
+
+// Ask the library to connect to a random replica of 'mymaster', rather than the master node
+cfg.sentinel.server_role = role::replica;
+----
+
+
+== Sentinel authentication
+
+If your Sentinels require authentication, 
+you can use xref:reference:boost/redis/sentinel_config/setup.adoc[`config::sentinel::setup`]
+to provide credentials.
+This request is executed immediately after connecting to Sentinels, and
+before any other command:
+
+[source,cpp]
+----
+// Set up Sentinel
+config cfg;
+cfg.sentinel.addresses = {
+    {"sentinel1.example.com", "26379"},
+    {"sentinel2.example.com", "26379"},
+    {"sentinel3.example.com", "26379"},
+};
+cfg.sentinel.master_name = "mymaster";
+
+// By default, setup contains a 'HELLO 3' command.
+// Override it to add an AUTH clause to it with out credentials.
+cfg.sentinel.setup.clear();
+cfg.sentinel.setup.push("HELLO", 3, "AUTH", "sentinel_user", "sentinel_password");
+
+// cfg.sentinel.setup applies to Sentinels, only.
+// Use cfg.setup to authenticate to masters/replicas.
+cfg.use_setup = true; // Required for cfg.setup to be used, for historic reasons
+cfg.setup.clear();
+cfg.setup.push("HELLO", 3, "AUTH", "master_user", "master_password");
+----
+
+== Using TLS with Sentinels
+
+You might use TLS with Sentinels only, masters/replicas only, or both by adjusting
+xref:reference:boost/redis/sentinel_config/use_ssl.adoc[`config::sentinel::use_ssl`]
+and xref:reference:boost/redis/config/use_ssl.adoc[`config::use_ssl`]:
+
+[source,cpp]
+----
+// Set up Sentinel
+config cfg;
+cfg.sentinel.addresses = {
+    {"sentinel1.example.com", "26379"},
+    {"sentinel2.example.com", "26379"},
+    {"sentinel3.example.com", "26379"},
+};
+cfg.sentinel.master_name = "mymaster";
+
+// Adjust these switches to enable/disable TLS
+cfg.use_ssl = true;          // Applies to masters and replicas
+cfg.sentinel.use_ssl = true; // Applies to Sentinels
+----
+
+== Sentinel algorithm
+
+This section details how `async_run` interacts with Sentinel.
+Most of the algorithm follows
+https://redis.io/docs/latest/develop/reference/sentinel-clients/[the official Sentinel client guidelines].
+Some of these details may vary between library versions.
+
+* Connections maintain an internal list of Sentinels, bootstrapped from
+  xref:reference:boost/redis/sentinel_config/addresses.adoc[`config::sentinel::addresses`].
+* The first Sentinel in the list is contacted by performing the following:
+** A physical connection is established.
+** The setup request is executed.
+** The master's address is resolved using
+   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL GET-MASTER-NAME-BY-ADDR`].
+** If `config::sentinel::server_role` is `role::replica`, replica addresses are obtained using
+   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL REPLICAS`].
+   One replica is chosen randomly.
+** The address of other Sentinels also monitoring this master are retrieved using
+   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL SENTINELS`].
+* If a Sentinel is unreachable, doesn't know about the configured master,
+  or returns an error while executing the above requests, the next Sentinel in the list is tried.
+* If all Sentinels have been tried without success, `config::reconnect_wait_interval`
+  is waited, and the process starts again.
+* After a successful Sentinel response, the internal Sentinel list is updated
+  with any newly discovered Sentinels.
+  Sentinels in `config::sentinel::addresses` are always kept in the list,
+  even if they weren't present in the output of `SENTINEL SENTINELS`.
+* The retrieved address is used
+  to establish a connection with the master or replica.
+  A `ROLE` command is added at the end of the setup request.
+  This is used to detect situations where a Sentinel returns outdated
+  information due to a failover in process. If `ROLE` doesn't output
+  the expected role (`"master"` or `"slave"`, depending on `config::sentinel::server_role`)
+  `config::reconnect_wait_interval` is waited and Sentinel is contacted again.
+* The connection to the master/replica is run like any other connection.
+  If network errors or timeouts happen, `config::reconnect_wait_interval`
+  is waited and Sentinel is contacted again.

example/CMakeLists.txt

@@ -28,11 +28,11 @@ make_testable_example(cpp20_containers 20)
 make_testable_example(cpp20_json 20)
 make_testable_example(cpp20_unix_sockets 20)
 make_testable_example(cpp20_timeouts 20)
+make_testable_example(cpp20_sentinel 20)
 
 make_example(cpp20_subscriber 20)
 make_example(cpp20_streams 20)
 make_example(cpp20_echo_server 20)
-make_example(cpp20_resolve_with_sentinel 20)
 make_example(cpp20_intro_tls 20)
 
 # We test the protobuf example only on gcc.

example/cpp20_chat_room.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -30,11 +30,9 @@ using boost::asio::consign;
 using boost::asio::detached;
 using boost::asio::dynamic_buffer;
 using boost::asio::redirect_error;
-using boost::asio::use_awaitable;
 using boost::redis::config;
 using boost::redis::connection;
-using boost::redis::generic_response;
-using boost::redis::ignore;
+using boost::redis::generic_flat_response;
 using boost::redis::request;
 using boost::system::error_code;
 using namespace std::chrono_literals;
@@ -47,20 +45,24 @@ auto receiver(std::shared_ptr<connection> conn) -> awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
-   generic_response resp;
+   generic_flat_response resp;
    conn->set_receive_response(resp);
 
    while (conn->will_reconnect()) {
       // Subscribe to channels.
-      co_await conn->async_exec(req, ignore);
+      co_await conn->async_exec(req);
 
       // Loop reading Redis push messages.
       for (error_code ec;;) {
-         co_await conn->async_receive(redirect_error(use_awaitable, ec));
+         co_await conn->async_receive2(redirect_error(ec));
          if (ec)
             break;  // Connection lost, break so we can reconnect to channels.
-         std::cout << resp.value().at(1).value << " " << resp.value().at(2).value << " "
-                   << resp.value().at(3).value << std::endl;
+
+         for (auto const& elem: resp.value().get_view())
+            std::cout << elem.value << "\n";
+
+         std::cout << std::endl;
+
          resp.value().clear();
       }
    }
@@ -74,7 +76,7 @@ auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection
       auto n = co_await async_read_until(*in, dynamic_buffer(msg, 1024), "\n");
       request req;
       req.push("PUBLISH", "channel", msg);
-      co_await conn->async_exec(req, ignore);
+      co_await conn->async_exec(req);
       msg.erase(0, n);
    }
 }

example/cpp20_resolve_with_sentinel.cpp

@@ -1,77 +0,0 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/redirect_error.hpp>
-#include <boost/asio/use_awaitable.hpp>
-
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace asio = boost::asio;
-using endpoints = asio::ip::tcp::resolver::results_type;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::ignore_t;
-using boost::redis::config;
-using boost::redis::address;
-using boost::redis::connection;
-
-auto redir(boost::system::error_code& ec) { return asio::redirect_error(asio::use_awaitable, ec); }
-
-// For more info see
-// - https://redis.io/docs/manual/sentinel.
-// - https://redis.io/docs/reference/sentinel-clients.
-auto resolve_master_address(std::vector<address> const& addresses) -> asio::awaitable<address>
-{
-   request req;
-   req.push("SENTINEL", "get-master-addr-by-name", "mymaster");
-   req.push("QUIT");
-
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-
-   response<std::optional<std::array<std::string, 2>>, ignore_t> resp;
-   for (auto addr : addresses) {
-      boost::system::error_code ec;
-      config cfg;
-      cfg.addr = addr;
-      // TODO: async_run and async_exec should be lauched in
-      // parallel here so we can wait for async_run completion
-      // before eventually calling it again.
-      conn->async_run(cfg, asio::consign(asio::detached, conn));
-      co_await conn->async_exec(req, resp, redir(ec));
-      conn->cancel();
-      if (!ec && std::get<0>(resp))
-         co_return address{
-            std::get<0>(resp).value().value().at(0),
-            std::get<0>(resp).value().value().at(1)};
-   }
-
-   co_return address{};
-}
-
-auto co_main(config cfg) -> asio::awaitable<void>
-{
-   // A list of sentinel addresses from which only one is responsive.
-   // This simulates sentinels that are down.
-   std::vector<address> const addresses{
-      address{"foo", "26379"},
-      address{"bar", "26379"},
-      cfg.addr
-   };
-
-   auto const ep = co_await resolve_master_address(addresses);
-
-   std::clog << "Host: " << ep.host << "\n"
-             << "Port: " << ep.port << "\n"
-             << std::flush;
-}
-
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)

example/cpp20_sentinel.cpp

@@ -0,0 +1,60 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/connection.hpp>
+
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/consign.hpp>
+#include <boost/asio/detached.hpp>
+
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+namespace asio = boost::asio;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::config;
+using boost::redis::connection;
+
+// Called from the main function (see main.cpp)
+auto co_main(config cfg) -> asio::awaitable<void>
+{
+   // Boost.Redis has built-in support for Sentinel deployments.
+   // To enable it, set the fields in config shown here.
+   // sentinel.addresses should contain a list of (hostname, port) pairs
+   // where Sentinels are listening. IPs can also be used.
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+      {"localhost", "26380"},
+      {"localhost", "26381"},
+   };
+
+   // Set master_name to the identifier that you configured
+   // in the "sentinel monitor" statement of your sentinel.conf file
+   cfg.sentinel.master_name = "mymaster";
+
+   // async_run will contact the Sentinels, obtain the master address,
+   // connect to it and keep the connection healthy. If a failover happens,
+   // the address will be resolved again and the new elected master will be contacted.
+   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
+   conn->async_run(cfg, asio::consign(asio::detached, conn));
+
+   // You can now use the connection normally, as you would use a connection to a single master.
+   request req;
+   req.push("PING", "Hello world");
+   response<std::string> resp;
+
+   // Execute the request.
+   co_await conn->async_exec(req, resp);
+   conn->cancel();
+
+   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
+}
+
+#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)

example/cpp20_subscriber.cpp

@@ -1,11 +1,10 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/redis/logger.hpp>
 
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/co_spawn.hpp>
@@ -22,12 +21,8 @@
 namespace asio = boost::asio;
 using namespace std::chrono_literals;
 using boost::redis::request;
-using boost::redis::generic_response;
-using boost::redis::consume_one;
-using boost::redis::logger;
+using boost::redis::generic_flat_response;
 using boost::redis::config;
-using boost::redis::ignore;
-using boost::redis::error;
 using boost::system::error_code;
 using boost::redis::connection;
 using asio::signal_set;
@@ -54,30 +49,29 @@ auto receiver(std::shared_ptr<connection> conn) -> asio::awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
-   generic_response resp;
+   generic_flat_response resp;
    conn->set_receive_response(resp);
 
    // Loop while reconnection is enabled
    while (conn->will_reconnect()) {
       // Reconnect to the channels.
-      co_await conn->async_exec(req, ignore);
+      co_await conn->async_exec(req);
 
-      // Loop reading Redis pushs messages.
+      // Loop to read Redis push messages.
       for (error_code ec;;) {
-         // First tries to read any buffered pushes.
-         conn->receive(ec);
-         if (ec == error::sync_receive_push_failed) {
-            ec = {};
-            co_await conn->async_receive(asio::redirect_error(asio::use_awaitable, ec));
-         }
-
+         // Wait for pushes
+         co_await conn->async_receive2(asio::redirect_error(ec));
          if (ec)
             break;  // Connection lost, break so we can reconnect to channels.
 
-         std::cout << resp.value().at(1).value << " " << resp.value().at(2).value << " "
-                   << resp.value().at(3).value << std::endl;
+         // The response must be consumed without suspending the
+         // coroutine i.e. without the use of async operations.
+         for (auto const& elem: resp.value().get_view())
+            std::cout << elem.value << "\n";
 
-         consume_one(resp);
+         std::cout << std::endl;
+
+         resp.value().clear();
       }
    }
 }

include/boost/redis/adapter/any_adapter.hpp

@@ -12,9 +12,7 @@
 
 #include <boost/system/error_code.hpp>
 
-#include <cstddef>
 #include <functional>
-#include <string_view>
 #include <type_traits>
 
 namespace boost::redis {
@@ -50,20 +48,7 @@ public:
    using impl_t = std::function<void(parse_event, resp3::node_view const&, system::error_code&)>;
 
    template <class T>
-   static auto create_impl(T& resp) -> impl_t
-   {
-      using namespace boost::redis::adapter;
-      return [adapter2 = boost_redis_adapt(resp)](
-                  any_adapter::parse_event ev,
-                  resp3::node_view const& nd,
-                  system::error_code& ec) mutable {
-         switch (ev) {
-            case parse_event::init: adapter2.on_init(); break;
-            case parse_event::node: adapter2.on_node(nd, ec); break;
-            case parse_event::done: adapter2.on_done(); break;
-         }
-      };
-   }
+   static auto create_impl(T& resp) -> impl_t;
 
    /// Contructs from a type erased adaper
    any_adapter(impl_t fn = [](parse_event, resp3::node_view const&, system::error_code&) { })
@@ -109,6 +94,32 @@ private:
    impl_t impl_;
 };
 
+namespace detail {
+
+template <class Adapter>
+any_adapter::impl_t make_any_adapter_impl(Adapter&& value)
+{
+   return [adapter = std::move(value)](
+             any_adapter::parse_event ev,
+             resp3::node_view const& nd,
+             system::error_code& ec) mutable {
+      switch (ev) {
+         case any_adapter::parse_event::init: adapter.on_init(); break;
+         case any_adapter::parse_event::node: adapter.on_node(nd, ec); break;
+         case any_adapter::parse_event::done: adapter.on_done(); break;
+      }
+   };
+}
+
+}  // namespace detail
+
 }  // namespace boost::redis
 
+template <class T>
+auto boost::redis::any_adapter::create_impl(T& resp) -> impl_t
+{
+   using adapter::boost_redis_adapt;
+   return detail::make_any_adapter_impl(boost_redis_adapt(resp));
+}
+
 #endif

include/boost/redis/adapter/detail/adapters.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -12,6 +12,8 @@
 #include <boost/redis/resp3/node.hpp>
 #include <boost/redis/resp3/serialization.hpp>
 #include <boost/redis/resp3/type.hpp>
+#include <boost/redis/resp3/flat_tree.hpp>
+#include <boost/redis/response.hpp>
 
 #include <boost/assert.hpp>
 
@@ -176,6 +178,97 @@ public:
    }
 };
 
+template <>
+class general_aggregate<resp3::tree> {
+private:
+   resp3::tree* tree_ = nullptr;
+
+public:
+   explicit general_aggregate(resp3::tree* c = nullptr)
+   : tree_(c)
+   { }
+
+   void on_init() { }
+   void on_done() { }
+
+   template <class String>
+   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   {
+      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
+
+      resp3::node tmp;
+      tmp.data_type = nd.data_type;
+      tmp.aggregate_size = nd.aggregate_size;
+      tmp.depth = nd.depth;
+      tmp.value = std::string{std::cbegin(nd.value), std::cend(nd.value)};
+
+      tree_->push_back(std::move(tmp));
+   }
+};
+
+template <>
+class general_aggregate<generic_flat_response> {
+private:
+   generic_flat_response* tree_ = nullptr;
+
+public:
+   explicit general_aggregate(generic_flat_response* c = nullptr)
+   : tree_(c)
+   { }
+
+   void on_init() { }
+   void on_done()
+   {
+      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
+      if (tree_->has_value()) {
+         tree_->value().notify_done();
+      }
+   }
+
+   template <class String>
+   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   {
+      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
+      switch (nd.data_type) {
+         case resp3::type::blob_error:
+         case resp3::type::simple_error:
+            *tree_ = error{
+               nd.data_type,
+               std::string{std::cbegin(nd.value), std::cend(nd.value)}
+            };
+            break;
+         default:
+            if (tree_->has_value()) {
+               (**tree_).push(nd);
+            }
+      }
+   }
+};
+
+template <>
+class general_aggregate<resp3::flat_tree> {
+private:
+   resp3::flat_tree* tree_ = nullptr;
+
+public:
+   explicit general_aggregate(resp3::flat_tree* c = nullptr)
+   : tree_(c)
+   { }
+
+   void on_init() { }
+   void on_done()
+   {
+      tree_->notify_done();
+   }
+
+   template <class String>
+   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   {
+      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
+      tree_->push(nd);
+   }
+};
+
 template <class Node>
 class general_simple {
 private:

include/boost/redis/adapter/detail/response_traits.hpp

@@ -92,8 +92,32 @@ struct response_traits<result<ignore_t>> {
 };
 
 template <class String, class Allocator>
-struct response_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
-   using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
+struct response_traits<result<resp3::basic_tree<String, Allocator>>> {
+   using response_type = result<resp3::basic_tree<String, Allocator>>;
+   using adapter_type = general_aggregate<response_type>;
+
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
+template <class String>
+struct response_traits<resp3::basic_tree<String>> {
+   using response_type = resp3::basic_tree<String>;
+   using adapter_type = general_aggregate<response_type>;
+
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
+template <>
+struct response_traits<resp3::flat_tree> {
+   using response_type = resp3::flat_tree;
+   using adapter_type = general_aggregate<response_type>;
+
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
+template <>
+struct response_traits<generic_flat_response> {
+   using response_type = generic_flat_response;
    using adapter_type = general_aggregate<response_type>;
 
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }

include/boost/redis/adapter/detail/result_traits.hpp

@@ -13,6 +13,8 @@
 #include <boost/redis/error.hpp>
 #include <boost/redis/ignore.hpp>
 #include <boost/redis/resp3/type.hpp>
+#include <boost/redis/resp3/tree.hpp>
+#include <boost/redis/resp3/flat_tree.hpp>
 
 #include <boost/mp11.hpp>
 
@@ -56,12 +58,33 @@ struct result_traits<result<resp3::basic_node<T>>> {
 };
 
 template <class String, class Allocator>
-struct result_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
+struct result_traits<result<resp3::basic_tree<String, Allocator>>> {
    using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
    using adapter_type = adapter::detail::general_aggregate<response_type>;
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
+template <class String>
+struct result_traits<resp3::basic_tree<String>> {
+   using response_type = resp3::basic_tree<String>;
+   using adapter_type = adapter::detail::general_aggregate<response_type>;
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
+template <>
+struct result_traits<generic_flat_response> {
+   using response_type = generic_flat_response;
+   using adapter_type = general_aggregate<response_type>;
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
+template <>
+struct result_traits<resp3::flat_tree> {
+   using response_type = resp3::flat_tree;
+   using adapter_type = general_aggregate<response_type>;
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
 template <class T>
 using adapter_t = typename result_traits<std::decay_t<T>>::adapter_type;
 

include/boost/redis/config.hpp

@@ -13,6 +13,7 @@
 #include <limits>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace boost::redis {
 
@@ -24,12 +25,130 @@ struct address {
    std::string port = "6379";
 };
 
-/// Configure parameters used by the connection classes.
-struct config {
-   /// Uses SSL instead of a plain connection.
+/** @brief Compares two addresses for equality.
+ *  @relates address
+ *
+ *  @param a Left hand side address.
+ *  @param b Right hand side address.
+ */
+inline bool operator==(address const& a, address const& b)
+{
+   return a.host == b.host && a.port == b.port;
+}
+
+/** @brief Compares two addresses for inequality.
+ *  @relates address
+ *
+ *  @param a Left hand side address.
+ *  @param b Right hand side address.
+ */
+inline bool operator!=(address const& a, address const& b) { return !(a == b); }
+
+/// Identifies the possible roles of a Redis server.
+enum class role
+{
+   /// The server is a master.
+   master,
+
+   /// The server is a replica.
+   replica,
+};
+
+/// Configuration values to use when using Sentinel.
+struct sentinel_config {
+   /**
+    * @brief A list of (hostname, port) pairs where the Sentinels are listening.
+    *
+    * Sentinels in this list will be contacted in order, until a successful
+    * connection is made. At this point, the `SENTINEL SENTINELS` command
+    * will be used to retrieve any additional Sentinels monitoring the configured master.
+    * Thus, it is not required to keep this list comprehensive - if Sentinels are added
+    * later, they will be detected at runtime.
+    *
+    * Sentinel will only be used if this value is not empty.
+    *
+    * Numeric IP addresses are also allowed as hostnames.
+    */
+   std::vector<address> addresses{};
+
+   /**
+    * @brief The name of the master to connect to, as configured in the
+    *        `sentinel monitor` statement in `sentinel.conf`.
+    *
+    * This field is required even when connecting to replicas.
+    */
+   std::string master_name{};
+
+   /**
+    * @brief Whether connections to Sentinels should use TLS or not.
+    *        Does not affect connections to masters.
+    *
+    * When set to `true`, physical connections to Sentinels will be established
+    * using TLS. This setting does *not* influence how masters and replicas are contacted.
+    * To use TLS when connecting to these, set @ref config::use_ssl to `true`.
+    */
    bool use_ssl = false;
 
-   /// For TCP connections, hostname and port of the Redis server.
+   /**
+    * @brief A request to be sent to Sentinels upon connection establishment.
+    *
+    * This request is executed every time a Sentinel is contacted, and before
+    * commands like `SENTINEL GET-MASTER-NAME-BY-ADDR` are run.
+    * By default, this field contains a `HELLO 3` command.
+    * You can use this request to set up any authorization required by Sentinels.
+    *
+    * This request should ensure that the connection is upgraded to RESP3
+    * by executing `HELLO 3` or similar. RESP2 is not supported yet.
+    */
+   request setup = detail::make_hello_request();
+
+   /**
+    * @brief Time span that the Sentinel resolve operation is allowed to elapse.
+    *        Does not affect connections to masters and replicas, controlled by @ref config::resolve_timeout.
+    */
+   std::chrono::steady_clock::duration resolve_timeout = std::chrono::milliseconds{500};
+
+   /**
+    * @brief Time span that the Sentinel connect operation is allowed to elapse.
+    *        Does not affect connections to masters and replicas, controlled by @ref config::connect_timeout.
+    */
+   std::chrono::steady_clock::duration connect_timeout = std::chrono::milliseconds{500};
+
+   /**
+    * @brief Time span that the Sentinel TLS handshake operation is allowed to elapse.
+    *        Does not affect connections to masters and replicas, controlled by @ref config::ssl_handshake_timeout.
+    */
+   std::chrono::steady_clock::duration ssl_handshake_timeout = std::chrono::seconds{5};
+
+   /**
+    * @brief Time span that the Sentinel request/response exchange is allowed to elapse.
+    *        Includes executing the commands in @ref setup and the commands required to
+    *        resolve the server's address.
+    */
+   std::chrono::steady_clock::duration request_timeout = std::chrono::seconds{5};
+
+   /**
+    * @brief Whether to connect to a Redis master or to a replica.
+    *
+    * The library resolves and connects to the Redis master, by default.
+    * Set this value to @ref role::replica to connect to one of the replicas
+    * of the master identified by @ref master_name.
+    * The particular replica will be chosen randomly.
+    */
+   role server_role = role::master;
+};
+
+/// Configure parameters used by the connection classes.
+struct config {
+   /**
+    * @brief Whether to use TLS instead of plaintext connections.
+    *
+    * When using Sentinel, configures whether to use TLS when connecting to masters and replicas.
+    * Use @ref sentinel_config::use_ssl to control TLS for Sentinels.
+    */
+   bool use_ssl = false;
+
+   /// For TCP connections, hostname and port of the Redis server. Ignored when using Sentinel.
    address addr = address{"127.0.0.1", "6379"};
 
    /**
@@ -37,8 +156,11 @@ struct config {
     *
     * If non-empty, communication with the server will happen using
     * UNIX domain sockets, and @ref addr will be ignored.
+    * 
     * UNIX domain sockets can't be used with SSL: if `unix_socket` is non-empty,
-    * @ref use_ssl must be `false`.
+    * @ref use_ssl must be `false`. UNIX domain sockets can't be used with Sentinel, either.
+    *
+    * UNIX domain sockets can't be used with Sentinel.
     */
    std::string unix_socket;
 
@@ -51,6 +173,9 @@ struct config {
     * If the username equals the literal `"default"` (the default)
     * and no password is specified, the `HELLO` command is sent
     * without authentication parameters.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Use @ref sentinel_config::setup to configure authorization for Sentinels.
     */
    std::string username = "default";
 
@@ -63,6 +188,9 @@ struct config {
     * If the username equals the literal `"default"` (the default)
     * and no password is specified, the `HELLO` command is sent
     * without authentication parameters.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Use @ref sentinel_config::setup to configure authorization for Sentinels.
     */
    std::string password;
 
@@ -71,6 +199,9 @@ struct config {
     * If @ref use_setup is false (the default), during connection establishment,
     * a `HELLO` command is sent. If this field is not empty, the `HELLO` command
     * will contain a `SETNAME` subcommand containing this value.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Use @ref sentinel_config::setup to configure this value for Sentinels.
     */
    std::string clientname = "Boost.Redis";
 
@@ -80,6 +211,8 @@ struct config {
     * non-empty optional, and its value is different than zero,
     * a `SELECT` command will be issued during connection establishment to set the logical
     * database index. By default, no `SELECT` command is sent.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
     */
    std::optional<int> database_index = 0;
 
@@ -95,13 +228,22 @@ struct config {
     */
    std::string log_prefix = "(Boost.Redis) ";
 
-   /// Time span that the resolve operation is allowed to elapse.
+   /**
+    * @brief Time span that the resolve operation is allowed to elapse.
+    *        When using Sentinel, this setting applies to masters and replicas.
+    */
    std::chrono::steady_clock::duration resolve_timeout = std::chrono::seconds{10};
 
-   /// Time span that the connect operation is allowed to elapse.
+   /**
+    * @brief Time span that the connect operation is allowed to elapse.
+    *        When using Sentinel, this setting applies to masters and replicas.
+    */
    std::chrono::steady_clock::duration connect_timeout = std::chrono::seconds{10};
 
-   /// Time span that the SSL handshake operation is allowed to elapse.
+   /**
+    * @brief Time span that the SSL handshake operation is allowed to elapse.
+    *        When using Sentinel, this setting applies to masters and replicas.
+    */
    std::chrono::steady_clock::duration ssl_handshake_timeout = std::chrono::seconds{10};
 
    /** @brief Time span between successive health checks.
@@ -123,18 +265,28 @@ struct config {
     *
     * The exact timeout values are *not* part of the interface, and might change
     * in future versions.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Sentinels are not health-checked.
     */
    std::chrono::steady_clock::duration health_check_interval = std::chrono::seconds{2};
 
    /** @brief Time span to wait between successive connection retries.
-    *  Set to zero to disable reconnection.
+    *         Set to zero to disable reconnection.
+    *
+    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
+    * If none of the configured Sentinels can be contacted, this time span will
+    * be waited before trying again. After a connection error with a master or replica
+    * is encountered, this time span will be waited before contacting Sentinels again.
     */
    std::chrono::steady_clock::duration reconnect_wait_interval = std::chrono::seconds{1};
 
    /** @brief Maximum size of the socket read-buffer in bytes.
     *  
-    *  Sets a limit on how much data is allowed to be read into the
-    *  read buffer. It can be used to prevent DDOS.
+    * Sets a limit on how much data is allowed to be read into the
+    * read buffer. It can be used to prevent DDOS.
+    *
+    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
     */
    std::size_t max_read_size = (std::numeric_limits<std::size_t>::max)();
 
@@ -144,6 +296,8 @@ struct config {
     * needed. This can help avoiding some memory allocations. Once the
     * maximum size is reached no more memory allocations are made
     * since the buffer is reused.
+    *
+    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
     */
    std::size_t read_buffer_append_size = 4096;
 
@@ -168,6 +322,9 @@ struct config {
     * systems that don't support `HELLO`.
     *
     * By default, this field is false, and @ref setup will not be used.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Use @ref sentinel_config::setup for Sentinels.
     */
    bool use_setup = false;
 
@@ -177,8 +334,17 @@ struct config {
     * @ref use_setup docs for more info.
     *
     * By default, `setup` contains a `"HELLO 3"` command.
+    *
+    * When using Sentinel, this setting applies to masters and replicas.
+    * Use @ref sentinel_config::setup for Sentinels.
     */
    request setup = detail::make_hello_request();
+
+   /**
+    * @brief Configuration values for Sentinel. Sentinel is enabled only if
+    *        @ref sentinel_config::addresses is not empty.
+    */
+   sentinel_config sentinel{};
 };
 
 }  // namespace boost::redis

include/boost/redis/connection.hpp

@@ -12,10 +12,12 @@
 #include <boost/redis/config.hpp>
 #include <boost/redis/detail/connection_state.hpp>
 #include <boost/redis/detail/exec_fsm.hpp>
+#include <boost/redis/detail/exec_one_fsm.hpp>
 #include <boost/redis/detail/multiplexer.hpp>
 #include <boost/redis/detail/reader_fsm.hpp>
 #include <boost/redis/detail/redis_stream.hpp>
 #include <boost/redis/detail/run_fsm.hpp>
+#include <boost/redis/detail/sentinel_resolve_fsm.hpp>
 #include <boost/redis/detail/writer_fsm.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/redis/logger.hpp>
@@ -32,9 +34,11 @@
 #include <boost/asio/bind_cancellation_slot.hpp>
 #include <boost/asio/bind_executor.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/cancel_after.hpp>
 #include <boost/asio/cancel_at.hpp>
 #include <boost/asio/cancellation_signal.hpp>
 #include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/compose.hpp>
 #include <boost/asio/deferred.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/experimental/cancellation_condition.hpp>
@@ -45,6 +49,7 @@
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/ssl/stream.hpp>
 #include <boost/asio/steady_timer.hpp>
+#include <boost/asio/write.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 
@@ -207,8 +212,148 @@ struct connection_impl {
    {
       st_.mpx.set_receive_adapter(std::move(adapter));
    }
+
+   std::size_t receive(system::error_code& ec)
+   {
+      std::size_t size = 0;
+
+      auto f = [&](system::error_code const& ec2, std::size_t n) {
+         ec = ec2;
+         size = n;
+      };
+
+      auto const res = receive_channel_.try_receive(f);
+      if (ec)
+         return 0;
+
+      if (!res)
+         ec = error::sync_receive_push_failed;
+
+      return size;
+   }
+
+   template <class CompletionToken>
+   auto async_receive2(CompletionToken&& token)
+   {
+      // clang-format off
+      return
+         receive_channel_.async_receive(
+            asio::deferred(
+               [this](system::error_code ec, std::size_t)
+               {
+                  if (!ec) {
+                     auto f = [](system::error_code, std::size_t) {
+                       // There is no point in checking for errors
+                       // here since async_receive just completed
+                       // without errors.
+                     };
+
+                     // We just want to drain the channel.
+                     while (receive_channel_.try_receive(f));
+                  }
+
+                  return asio::deferred.values(ec);
+               }
+            )
+         )(std::forward<CompletionToken>(token));
+      // clang-format on
+   }
 };
 
+template <class Executor>
+struct exec_one_op {
+   connection_impl<Executor>* conn_;
+   const request* req_;
+   exec_one_fsm fsm_;
+
+   explicit exec_one_op(connection_impl<Executor>& conn, const request& req, any_adapter resp)
+   : conn_(&conn)
+   , req_(&req)
+   , fsm_(std::move(resp), req.get_expected_responses())
+   { }
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {}, std::size_t bytes_written = 0u)
+   {
+      exec_one_action act = fsm_.resume(
+         conn_->st_.mpx.get_read_buffer(),
+         ec,
+         bytes_written,
+         self.get_cancellation_state().cancelled());
+
+      switch (act.type) {
+         case exec_one_action_type::done: self.complete(act.ec); return;
+         case exec_one_action_type::write:
+            asio::async_write(conn_->stream_, asio::buffer(req_->payload()), std::move(self));
+            return;
+         case exec_one_action_type::read_some:
+            conn_->stream_.async_read_some(
+               conn_->st_.mpx.get_read_buffer().get_prepared(),
+               std::move(self));
+            return;
+      }
+   }
+};
+
+template <class Executor, class CompletionToken>
+auto async_exec_one(
+   connection_impl<Executor>& conn,
+   const request& req,
+   any_adapter resp,
+   CompletionToken&& token)
+{
+   return asio::async_compose<CompletionToken, void(system::error_code)>(
+      exec_one_op<Executor>{conn, req, std::move(resp)},
+      token,
+      conn);
+}
+
+template <class Executor>
+struct sentinel_resolve_op {
+   connection_impl<Executor>* conn_;
+   sentinel_resolve_fsm fsm_;
+
+   explicit sentinel_resolve_op(connection_impl<Executor>& conn)
+   : conn_(&conn)
+   { }
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {})
+   {
+      auto* conn = conn_;  // Prevent potential use-after-move errors with cancel_after
+      sentinel_action act = fsm_.resume(conn_->st_, ec, self.get_cancellation_state().cancelled());
+
+      switch (act.get_type()) {
+         case sentinel_action::type::done: self.complete(act.error()); return;
+         case sentinel_action::type::connect:
+            conn->stream_.async_connect(
+               make_sentinel_connect_params(conn->st_.cfg, act.connect_addr()),
+               conn->st_.logger,
+               std::move(self));
+            return;
+         case sentinel_action::type::request:
+            async_exec_one(
+               *conn,
+               conn->st_.cfg.sentinel.setup,
+               make_sentinel_adapter(conn->st_),
+               asio::cancel_after(
+                  conn->reconnect_timer_,  // should be safe to re-use this
+                  conn->st_.cfg.sentinel.request_timeout,
+                  std::move(self)));
+            return;
+      }
+   }
+};
+
+template <class Executor, class CompletionToken>
+auto async_sentinel_resolve(connection_impl<Executor>& conn, CompletionToken&& token)
+{
+   return asio::async_compose<CompletionToken, void(system::error_code)>(
+      sentinel_resolve_op<Executor>{conn},
+      token,
+      conn);
+}
+
 template <class Executor>
 struct writer_op {
    connection_impl<Executor>* conn_;
@@ -335,8 +480,14 @@ public:
          case run_action_type::immediate:
             asio::async_immediate(self.get_io_executor(), std::move(self));
             return;
+         case run_action_type::sentinel_resolve:
+            async_sentinel_resolve(*conn_, std::move(self));
+            return;
          case run_action_type::connect:
-            conn_->stream_.async_connect(conn_->st_.cfg, conn_->st_.logger, std::move(self));
+            conn_->stream_.async_connect(
+               make_run_connect_params(conn_->st_),
+               conn_->st_.logger,
+               std::move(self));
             return;
          case run_action_type::parallel_group:
             asio::experimental::make_parallel_group(
@@ -487,6 +638,8 @@ public:
     * This function establishes a connection to the Redis server and keeps
     * it healthy by performing the following operations:
     *
+    *  @li For Sentinel deployments (`config::sentinel::addresses` is not empty),
+    *      contacts Sentinels to obtain the address of the configured master.
     *  @li For TCP connections, resolves the server hostname passed in
     *      @ref boost::redis::config::addr.
     *  @li Establishes a physical connection to the server. For TCP connections,
@@ -593,7 +746,7 @@ public:
       return async_run(config{}, std::forward<CompletionToken>(token));
    }
 
-   /** @brief Receives server side pushes asynchronously.
+   /** @brief (Deprecated) Receives server side pushes asynchronously.
     *
     * When pushes arrive and there is no `async_receive` operation in
     * progress, pushed data, requests, and responses will be paused
@@ -623,12 +776,57 @@ public:
     * @param token Completion token.
     */
    template <class CompletionToken = asio::default_completion_token_t<executor_type>>
+   BOOST_DEPRECATED("Please use async_receive2 instead.")
    auto async_receive(CompletionToken&& token = {})
    {
       return impl_->receive_channel_.async_receive(std::forward<CompletionToken>(token));
    }
 
-   /** @brief Receives server pushes synchronously without blocking.
+   /** @brief Wait for server pushes asynchronously
+    *
+    * This function suspends until a server push is received by the
+    * connection. On completion an unspecified number of pushes will
+    * have been added to the response object set with @ref
+    * boost::redis::connection::set_receive_response.
+    *
+    * To prevent receiving an unbound number of pushes the connection
+    * blocks further read operations on the socket when 256 pushes
+    * accumulate internally (we don't make any commitment to this
+    * exact number). When that happens any `async_exec`s and
+    * health-checks won't make any progress and the connection may
+    * eventually timeout. To avoid that Apps should call
+    * `async_receive2` continuously in a loop.
+    *
+    * @Note To avoid deadlocks the task (e.g. coroutine) calling
+    * `async_receive2` should not call `async_exec` in a way where
+    * they could block each other.
+    *
+    * For an example see cpp20_subscriber.cpp. The completion token
+    * must have the following signature
+    *
+    * @code
+    * void f(system::error_code);
+    * @endcode
+    *
+    * @par Per-operation cancellation
+    * This operation supports the following cancellation types:
+    *
+    *   @li `asio::cancellation_type_t::terminal`.
+    *   @li `asio::cancellation_type_t::partial`.
+    *   @li `asio::cancellation_type_t::total`.
+    *
+    * Calling `basic_connection::cancel(operation::receive)` will
+    * also cancel any ongoing receive operations.
+    * 
+    * @param token Completion token.
+    */
+   template <class CompletionToken = asio::default_completion_token_t<executor_type>>
+   auto async_receive2(CompletionToken&& token = {})
+   {
+      return impl_->async_receive2(std::forward<CompletionToken>(token));
+   }
+
+   /** @brief (Deprecated) Receives server pushes synchronously without blocking.
     *
     *  Receives a server push synchronously by calling `try_receive` on
     *  the underlying channel. If the operation fails because
@@ -638,24 +836,8 @@ public:
     *  @param ec Contains the error if any occurred.
     *  @returns The number of bytes read from the socket.
     */
-   std::size_t receive(system::error_code& ec)
-   {
-      std::size_t size = 0;
-
-      auto f = [&](system::error_code const& ec2, std::size_t n) {
-         ec = ec2;
-         size = n;
-      };
-
-      auto const res = impl_->receive_channel_.try_receive(f);
-      if (ec)
-         return 0;
-
-      if (!res)
-         ec = error::sync_receive_push_failed;
-
-      return size;
-   }
+   BOOST_DEPRECATED("Please, use async_receive2 instead.")
+   std::size_t receive(system::error_code& ec) { return impl_->receive(ec); }
 
    /** @brief Executes commands on the Redis server asynchronously.
     *
@@ -837,7 +1019,7 @@ public:
       "the other member functions to interact with the connection.")
    auto const& next_layer() const noexcept { return impl_->stream_.next_layer(); }
 
-   /// Sets the response object of @ref async_receive operations.
+   /// Sets the response object of @ref async_receive2 operations.
    template <class Response>
    void set_receive_response(Response& resp)
    {
@@ -1028,13 +1210,22 @@ public:
 
    /// @copydoc basic_connection::async_receive
    template <class CompletionToken = asio::deferred_t>
+   BOOST_DEPRECATED("Please use async_receive2 instead.")
    auto async_receive(CompletionToken&& token = {})
    {
       return impl_.async_receive(std::forward<CompletionToken>(token));
    }
 
+   /// @copydoc basic_connection::async_receive2
+   template <class CompletionToken = asio::deferred_t>
+   auto async_receive2(CompletionToken&& token = {})
+   {
+      return impl_.async_receive2(std::forward<CompletionToken>(token));
+   }
+
    /// @copydoc basic_connection::receive
-   std::size_t receive(system::error_code& ec) { return impl_.receive(ec); }
+   BOOST_DEPRECATED("Please use async_receive2 instead.")
+   std::size_t receive(system::error_code& ec) { return impl_.impl_->receive(ec); }
 
    /**
     * @brief Calls @ref boost::redis::basic_connection::async_exec.

include/boost/redis/detail/connect_fsm.hpp

@@ -9,8 +9,6 @@
 #ifndef BOOST_REDIS_CONNECT_FSM_HPP
 #define BOOST_REDIS_CONNECT_FSM_HPP
 
-#include <boost/redis/config.hpp>
-
 #include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/system/error_code.hpp>
@@ -62,17 +60,13 @@ struct connect_action {
 
 class connect_fsm {
    int resume_point_{0};
-   const config* cfg_{nullptr};
    buffered_logger* lgr_{nullptr};
 
 public:
-   connect_fsm(const config& cfg, buffered_logger& lgr) noexcept
-   : cfg_(&cfg)
-   , lgr_(&lgr)
+   connect_fsm(buffered_logger& lgr) noexcept
+   : lgr_(&lgr)
    { }
 
-   const config& get_config() const { return *cfg_; }
-
    connect_action resume(
       system::error_code ec,
       const asio::ip::tcp::resolver::results_type& resolver_results,

include/boost/redis/detail/connect_params.hpp

@@ -0,0 +1,65 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_CONNECT_PARAMS_HPP
+#define BOOST_REDIS_CONNECT_PARAMS_HPP
+
+// Parameters used by redis_stream::async_connect
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/connect_fsm.hpp>
+
+#include <chrono>
+#include <string_view>
+
+namespace boost::redis::detail {
+
+// Fully identifies where a server is listening. Reference type.
+class any_address_view {
+   transport_type type_;
+   union {
+      const address* tcp_;
+      std::string_view unix_;
+   };
+
+public:
+   any_address_view(const address& addr, bool use_ssl) noexcept
+   : type_(use_ssl ? transport_type::tcp_tls : transport_type::tcp)
+   , tcp_(&addr)
+   { }
+
+   explicit any_address_view(std::string_view unix_socket) noexcept
+   : type_(transport_type::unix_socket)
+   , unix_(unix_socket)
+   { }
+
+   transport_type type() const { return type_; }
+
+   const address& tcp_address() const
+   {
+      BOOST_ASSERT(type_ == transport_type::tcp || type_ == transport_type::tcp_tls);
+      return *tcp_;
+   }
+
+   std::string_view unix_socket() const
+   {
+      BOOST_ASSERT(type_ == transport_type::unix_socket);
+      return unix_;
+   }
+};
+
+struct connect_params {
+   any_address_view addr;
+   std::chrono::steady_clock::duration resolve_timeout;
+   std::chrono::steady_clock::duration connect_timeout;
+   std::chrono::steady_clock::duration ssl_handshake_timeout;
+};
+
+}  // namespace boost::redis::detail
+
+#endif  // BOOST_REDIS_CONNECTOR_HPP

include/boost/redis/detail/connection_state.hpp

@@ -13,20 +13,46 @@
 #include <boost/redis/detail/multiplexer.hpp>
 #include <boost/redis/logger.hpp>
 #include <boost/redis/request.hpp>
+#include <boost/redis/resp3/node.hpp>
 #include <boost/redis/response.hpp>
 
+#include <random>
 #include <string>
+#include <vector>
 
 namespace boost::redis::detail {
 
+// A random engine that gets seeded lazily.
+// Seeding with std::random_device is not trivial and might fail.
+class lazy_random_engine {
+   bool seeded_{};
+   std::minstd_rand eng_;
+
+public:
+   lazy_random_engine() = default;
+   std::minstd_rand& get()
+   {
+      if (!seeded_) {
+         eng_.seed(static_cast<std::minstd_rand::result_type>(std::random_device{}()));
+         seeded_ = true;
+      }
+      return eng_;
+   }
+};
+
 // Contains all the members in connection that don't depend on the Executor.
 // Makes implementing sans-io algorithms easier
 struct connection_state {
    buffered_logger logger;
    config cfg{};
    multiplexer mpx{};
-   std::string setup_diagnostic{};
+   std::string diagnostic{};  // Used by the setup request and Sentinel
    request ping_req{};
+
+   // Sentinel stuff
+   lazy_random_engine eng{};
+   std::vector<address> sentinels{};
+   std::vector<resp3::node> sentinel_resp_nodes{};  // for parsing
 };
 
 }  // namespace boost::redis::detail

include/boost/redis/detail/exec_one_fsm.hpp

@@ -0,0 +1,69 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_EXEC_ONE_FSM_HPP
+#define BOOST_REDIS_EXEC_ONE_FSM_HPP
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/resp3/parser.hpp>
+
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <cstddef>
+
+// Sans-io algorithm for async_exec_one, as a finite state machine
+
+namespace boost::redis::detail {
+
+class read_buffer;
+
+// What should we do next?
+enum class exec_one_action_type
+{
+   done,       // Call the final handler
+   write,      // Write the request
+   read_some,  // Read into the read buffer
+};
+
+struct exec_one_action {
+   exec_one_action_type type;
+   system::error_code ec;
+
+   exec_one_action(exec_one_action_type type) noexcept
+   : type{type}
+   { }
+
+   exec_one_action(system::error_code ec) noexcept
+   : type{exec_one_action_type::done}
+   , ec{ec}
+   { }
+};
+
+class exec_one_fsm {
+   int resume_point_{0};
+   any_adapter adapter_;
+   std::size_t remaining_responses_;
+   resp3::parser parser_;
+
+public:
+   exec_one_fsm(any_adapter resp, std::size_t expected_responses)
+   : adapter_(std::move(resp))
+   , remaining_responses_(expected_responses)
+   { }
+
+   exec_one_action resume(
+      read_buffer& buffer,
+      system::error_code ec,
+      std::size_t bytes_transferred,
+      asio::cancellation_type_t cancel_state);
+};
+
+}  // namespace boost::redis::detail
+
+#endif  // BOOST_REDIS_CONNECTOR_HPP

include/boost/redis/detail/multiplexer.hpp

@@ -181,6 +181,12 @@ public:
       return std::string_view{write_buffer_}.substr(write_offset_);
    }
 
+   [[nodiscard]]
+   auto get_read_buffer() noexcept -> read_buffer&
+   {
+      return read_buffer_;
+   }
+
    [[nodiscard]]
    auto get_prepared_read_buffer() noexcept -> read_buffer::span_type;
 

include/boost/redis/detail/read_buffer.hpp

@@ -61,6 +61,7 @@ public:
 private:
    config cfg_ = config{};
    std::vector<char> buffer_;
+   std::size_t offset_ = 0;
    std::size_t append_buf_begin_ = 0;
 };
 

include/boost/redis/detail/redis_stream.hpp

@@ -9,6 +9,7 @@
 
 #include <boost/redis/config.hpp>
 #include <boost/redis/detail/connect_fsm.hpp>
+#include <boost/redis/detail/connect_params.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/redis/logger.hpp>
 
@@ -24,6 +25,7 @@
 #include <boost/asio/ssl/stream.hpp>
 #include <boost/asio/ssl/stream_base.hpp>
 #include <boost/asio/steady_timer.hpp>
+#include <boost/assert.hpp>
 #include <boost/system/error_code.hpp>
 
 #include <utility>
@@ -48,12 +50,14 @@ class redis_stream {
    struct connect_op {
       redis_stream& obj_;
       connect_fsm fsm_;
+      connect_params params_;
 
       template <class Self>
       void execute_action(Self& self, connect_action act)
       {
-         auto& obj = this->obj_;  // prevent use-after-move errors
-         const auto& cfg = fsm_.get_config();
+         // Prevent use-after-move errors
+         auto& obj = this->obj_;
+         auto params = this->params_;
 
          switch (act.type) {
             case connect_action_type::unix_socket_close:
@@ -70,8 +74,8 @@ class redis_stream {
             case connect_action_type::unix_socket_connect:
 #ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
                obj.unix_socket_.async_connect(
-                  cfg.unix_socket,
-                  asio::cancel_after(obj.timer_, cfg.connect_timeout, std::move(self)));
+                  params.addr.unix_socket(),
+                  asio::cancel_after(obj.timer_, params.connect_timeout, std::move(self)));
 #else
                BOOST_ASSERT(false);
 #endif
@@ -79,9 +83,9 @@ class redis_stream {
 
             case connect_action_type::tcp_resolve:
                obj.resolv_.async_resolve(
-                  cfg.addr.host,
-                  cfg.addr.port,
-                  asio::cancel_after(obj.timer_, cfg.resolve_timeout, std::move(self)));
+                  params.addr.tcp_address().host,
+                  params.addr.tcp_address().port,
+                  asio::cancel_after(obj.timer_, params.resolve_timeout, std::move(self)));
                return;
             case connect_action_type::ssl_stream_reset:
                obj.reset_stream();
@@ -91,7 +95,7 @@ class redis_stream {
             case connect_action_type::ssl_handshake:
                obj.stream_.async_handshake(
                   asio::ssl::stream_base::client,
-                  asio::cancel_after(obj.timer_, cfg.ssl_handshake_timeout, std::move(self)));
+                  asio::cancel_after(obj.timer_, params.ssl_handshake_timeout, std::move(self)));
                return;
             case connect_action_type::done:        self.complete(act.ec); break;
             // Connect should use the specialized handler, where resolver results are available
@@ -124,11 +128,11 @@ class redis_stream {
       {
          auto act = fsm_.resume(ec, endpoints, obj_.st_, self.get_cancellation_state().cancelled());
          if (act.type == connect_action_type::tcp_connect) {
-            auto& obj = this->obj_;  // prevent use-after-free errors
+            auto& obj = this->obj_;  // prevent use-after-move errors
             asio::async_connect(
                obj.stream_.next_layer(),
                std::move(endpoints),
-               asio::cancel_after(obj.timer_, fsm_.get_config().connect_timeout, std::move(self)));
+               asio::cancel_after(obj.timer_, params_.connect_timeout, std::move(self)));
          } else {
             execute_action(self, act);
          }
@@ -172,10 +176,11 @@ public:
 
    // I/O
    template <class CompletionToken>
-   auto async_connect(const config& cfg, buffered_logger& l, CompletionToken&& token)
+   auto async_connect(const connect_params& params, buffered_logger& l, CompletionToken&& token)
    {
+      this->st_.type = params.addr.type();
       return asio::async_compose<CompletionToken, void(system::error_code)>(
-         connect_op{*this, connect_fsm(cfg, l)},
+         connect_op{*this, connect_fsm{l}, params},
          token);
    }
 

include/boost/redis/detail/run_fsm.hpp

@@ -9,6 +9,8 @@
 #ifndef BOOST_REDIS_RUN_FSM_HPP
 #define BOOST_REDIS_RUN_FSM_HPP
 
+#include <boost/redis/detail/connect_params.hpp>
+
 #include <boost/asio/cancellation_type.hpp>
 #include <boost/system/error_code.hpp>
 
@@ -25,6 +27,7 @@ enum class run_action_type
    done,                   // Call the final handler
    immediate,              // Call asio::async_immediate
    connect,                // Transport connection establishment
+   sentinel_resolve,       // Contact Sentinels to resolve the master's address
    parallel_group,         // Run the reader, writer and friends
    cancel_receive,         // Cancel the receiver channel
    wait_for_reconnection,  // Sleep for the reconnection period
@@ -57,6 +60,8 @@ public:
       asio::cancellation_type_t cancel_state);
 };
 
+connect_params make_run_connect_params(const connection_state& st);
+
 }  // namespace boost::redis::detail
 
 #endif  // BOOST_REDIS_CONNECTOR_HPP

include/boost/redis/detail/sentinel_resolve_fsm.hpp

@@ -0,0 +1,93 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_SENTINEL_RESOLVE_FSM_HPP
+#define BOOST_REDIS_SENTINEL_RESOLVE_FSM_HPP
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/connect_params.hpp>
+
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/assert.hpp>
+#include <boost/system/error_code.hpp>
+
+// Sans-io algorithm for async_sentinel_resolve, as a finite state machine
+
+namespace boost::redis::detail {
+
+// Forward decls
+struct connection_state;
+
+class sentinel_action {
+public:
+   enum class type
+   {
+      done,     // Call the final handler
+      connect,  // Transport connection establishment
+      request,  // Send the Sentinel request
+   };
+
+   sentinel_action(system::error_code ec) noexcept
+   : type_(type::done)
+   , ec_(ec)
+   { }
+
+   sentinel_action(const address& addr) noexcept
+   : type_(type::connect)
+   , connect_(&addr)
+   { }
+
+   static sentinel_action request() { return {type::request}; }
+
+   type get_type() const { return type_; }
+
+   [[nodiscard]]
+   system::error_code error() const
+   {
+      BOOST_ASSERT(type_ == type::done);
+      return ec_;
+   }
+
+   const address& connect_addr() const
+   {
+      BOOST_ASSERT(type_ == type::connect);
+      return *connect_;
+   }
+
+private:
+   type type_;
+   union {
+      system::error_code ec_;
+      const address* connect_;
+   };
+
+   sentinel_action(type type) noexcept
+   : type_(type)
+   { }
+};
+
+class sentinel_resolve_fsm {
+   int resume_point_{0};
+   std::size_t idx_{0u};
+
+public:
+   sentinel_resolve_fsm() = default;
+
+   sentinel_action resume(
+      connection_state& st,
+      system::error_code ec,
+      asio::cancellation_type_t cancel_state);
+};
+
+connect_params make_sentinel_connect_params(const config& cfg, const address& sentinel_addr);
+any_adapter make_sentinel_adapter(connection_state& st);
+
+}  // namespace boost::redis::detail
+
+#endif  // BOOST_REDIS_CONNECTOR_HPP

include/boost/redis/error.hpp

@@ -74,7 +74,7 @@ enum class error
    /// SSL handshake timeout
    ssl_handshake_timeout,
 
-   /// Can't receive push synchronously without blocking
+   /// (Deprecated) Can't receive push synchronously without blocking
    sync_receive_push_failed,
 
    /// Incompatible node depth.
@@ -94,6 +94,24 @@ enum class error
 
    /// Timeout while writing data to the server.
    write_timeout,
+
+   /// The configuration specified UNIX sockets with Sentinel, which is not supported.
+   sentinel_unix_sockets_unsupported,
+
+   /// No Sentinel could be used to obtain the address of the Redis server.
+   /// Sentinels might be unreachable, have authentication misconfigured or may not know about
+   /// the configured master. Turn logging on for details.
+   sentinel_resolve_failed,
+
+   /// The contacted server is not a master as expected.
+   /// This is likely a transient failure caused by a Sentinel failover in progress.
+   role_check_failed,
+
+   /// Expects a RESP3 string, but got a different data type.
+   expects_resp3_string,
+
+   /// Expects a RESP3 array, but got a different data type.
+   expects_resp3_array,
 };
 
 /**

include/boost/redis/impl/connect_fsm.ipp

@@ -61,20 +61,6 @@ struct log_traits<asio::ip::tcp::resolver::results_type> {
    }
 };
 
-inline transport_type transport_from_config(const config& cfg)
-{
-   if (cfg.unix_socket.empty()) {
-      if (cfg.use_ssl) {
-         return transport_type::tcp_tls;
-      } else {
-         return transport_type::tcp;
-      }
-   } else {
-      BOOST_ASSERT(!cfg.use_ssl);
-      return transport_type::unix_socket;
-   }
-}
-
 inline system::error_code translate_timeout_error(
    system::error_code io_ec,
    asio::cancellation_type_t cancel_state,
@@ -105,9 +91,9 @@ connect_action connect_fsm::resume(
 
    // Log it
    if (ec) {
-      log_info(*lgr_, "Error resolving the server hostname: ", ec);
+      log_info(*lgr_, "Connect: hostname resolution failed: ", ec);
    } else {
-      log_info(*lgr_, "Resolve results: ", resolver_results);
+      log_debug(*lgr_, "Connect: hostname resolution results: ", resolver_results);
    }
 
    // Delegate to the regular resume function
@@ -125,9 +111,9 @@ connect_action connect_fsm::resume(
 
    // Log it
    if (ec) {
-      log_info(*lgr_, "Failed to connect to the server: ", ec);
+      log_info(*lgr_, "Connect: TCP connect failed: ", ec);
    } else {
-      log_info(*lgr_, "Connected to ", selected_endpoint);
+      log_debug(*lgr_, "Connect: TCP connect succeeded. Selected endpoint: ", selected_endpoint);
    }
 
    // Delegate to the regular resume function
@@ -142,9 +128,6 @@ connect_action connect_fsm::resume(
    switch (resume_point_) {
       BOOST_REDIS_CORO_INITIAL
 
-      // Record the transport that we will be using
-      st.type = transport_from_config(*cfg_);
-
       if (st.type == transport_type::unix_socket) {
          // Reset the socket, to discard any previous state. Ignore any errors
          BOOST_REDIS_YIELD(resume_point_, 1, connect_action_type::unix_socket_close)
@@ -160,9 +143,9 @@ connect_action connect_fsm::resume(
 
          // Log it
          if (ec) {
-            log_info(*lgr_, "Failed to connect to the server: ", ec);
+            log_info(*lgr_, "Connect: UNIX socket connect failed: ", ec);
          } else {
-            log_info(*lgr_, "Connected to ", cfg_->unix_socket);
+            log_debug(*lgr_, "Connect: UNIX socket connect succeeded");
          }
 
          // If this failed, we can't continue
@@ -178,7 +161,7 @@ connect_action connect_fsm::resume(
          // Must be done before anything else is done on the stream.
          // We don't need to close the TCP socket if using plaintext TCP
          // because range-connect closes open sockets, while individual connect doesn't
-         if (cfg_->use_ssl && st.ssl_stream_used) {
+         if (st.type == transport_type::tcp_tls && st.ssl_stream_used) {
             BOOST_REDIS_YIELD(resume_point_, 3, connect_action_type::ssl_stream_reset)
          }
 
@@ -200,7 +183,7 @@ connect_action connect_fsm::resume(
             return ec;
          }
 
-         if (cfg_->use_ssl) {
+         if (st.type == transport_type::tcp_tls) {
             // Mark the SSL stream as used
             st.ssl_stream_used = true;
 
@@ -212,9 +195,9 @@ connect_action connect_fsm::resume(
 
             // Log it
             if (ec) {
-               log_info(*lgr_, "Failed to perform SSL handshake: ", ec);
+               log_info(*lgr_, "Connect: SSL handshake failed: ", ec);
             } else {
-               log_info(*lgr_, "Successfully performed SSL handshake");
+               log_debug(*lgr_, "Connect: SSL handshake succeeded");
             }
 
             // If this failed, we can't continue

include/boost/redis/impl/error.ipp

@@ -55,8 +55,19 @@ struct error_category_impl : system::error_category {
          case error::exceeds_maximum_read_buffer_size:
             return "Reading data from the socket would exceed the maximum size allowed of the read "
                    "buffer.";
-         case error::write_timeout:
-            return "Timeout while writing data to the server.";
+         case error::write_timeout: return "Timeout while writing data to the server.";
+         case error::sentinel_unix_sockets_unsupported:
+            return "The configuration specified UNIX sockets with Sentinel, which is not "
+                   "supported.";
+         case error::sentinel_resolve_failed:
+            return "No Sentinel could be used to obtain the address of the Redis server.";
+         case error::role_check_failed:
+            return "The contacted server does not have the expected role. "
+                   "This is likely a transient failure caused by a Sentinel failover in progress.";
+         case error::expects_resp3_string:
+            return "Expects a RESP3 string, but got a different data type.";
+         case error::expects_resp3_array:
+            return "Expects a RESP3 array, but got a different data type.";
          default: BOOST_ASSERT(false); return "Boost.Redis error.";
       }
    }

include/boost/redis/impl/exec_one_fsm.ipp

@@ -0,0 +1,95 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_EXEC_ONE_FSM_IPP
+#define BOOST_REDIS_EXEC_ONE_FSM_IPP
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/detail/coroutine.hpp>
+#include <boost/redis/detail/exec_one_fsm.hpp>
+#include <boost/redis/detail/read_buffer.hpp>
+#include <boost/redis/impl/is_terminal_cancel.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/parser.hpp>
+
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/assert.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <cstddef>
+
+namespace boost::redis::detail {
+
+exec_one_action exec_one_fsm::resume(
+   read_buffer& buffer,
+   system::error_code ec,
+   std::size_t bytes_transferred,
+   asio::cancellation_type_t cancel_state)
+{
+   switch (resume_point_) {
+      BOOST_REDIS_CORO_INITIAL
+
+      // Send the request to the server
+      BOOST_REDIS_YIELD(resume_point_, 1, exec_one_action_type::write)
+
+      // Errors and cancellations
+      if (is_terminal_cancel(cancel_state))
+         return system::error_code{asio::error::operation_aborted};
+      if (ec)
+         return ec;
+
+      // If the request didn't expect any response, we're done
+      if (remaining_responses_ == 0u)
+         return system::error_code{};
+
+      // Read responses until we're done
+      buffer.clear();
+      while (true) {
+         // Prepare the buffer to read some data
+         ec = buffer.prepare();
+         if (ec)
+            return ec;
+
+         // Read data
+         BOOST_REDIS_YIELD(resume_point_, 2, exec_one_action_type::read_some)
+
+         // Errors and cancellations
+         if (is_terminal_cancel(cancel_state))
+            return system::error_code{asio::error::operation_aborted};
+         if (ec)
+            return ec;
+
+         // Commit the data into the buffer
+         buffer.commit(bytes_transferred);
+
+         // Consume the data until we run out or all the responses have been read
+         while (resp3::parse(parser_, buffer.get_commited(), adapter_, ec)) {
+            // Check for errors
+            if (ec)
+               return ec;
+
+            // We've finished parsing a response
+            buffer.consume(parser_.get_consumed());
+            parser_.reset();
+
+            // When no more responses remain, we're done.
+            // Don't read ahead, even if more data is available
+            if (--remaining_responses_ == 0u)
+               return system::error_code{};
+         }
+      }
+   }
+
+   BOOST_ASSERT(false);
+   return system::error_code();
+}
+
+}  // namespace boost::redis::detail
+
+#endif

include/boost/redis/impl/flat_tree.ipp

@@ -0,0 +1,189 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Nikolai Vladimirov (nvladimirov.work@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/resp3/flat_tree.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/tree.hpp>
+
+#include <boost/assert.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <string_view>
+
+namespace boost::redis::resp3 {
+
+namespace detail {
+
+// Updates string views by performing pointer arithmetic
+inline void rebase_strings(view_tree& nodes, const char* old_base, const char* new_base)
+{
+   for (auto& nd : nodes) {
+      if (!nd.value.empty()) {
+         const auto offset = nd.value.data() - old_base;
+         BOOST_ASSERT(offset >= 0);
+         nd.value = {new_base + offset, nd.value.size()};
+      }
+   }
+}
+
+// --- Operations in flat_buffer ---
+
+// Compute the new capacity upon reallocation. We always use powers of 2,
+// starting in 512, to prevent many small allocations
+inline std::size_t compute_capacity(std::size_t current, std::size_t requested)
+{
+   std::size_t res = (std::max)(current, static_cast<std::size_t>(512u));
+   while (res < requested)
+      res *= 2u;
+   return res;
+}
+
+// Copy construction
+inline flat_buffer copy_construct(const flat_buffer& other)
+{
+   flat_buffer res{{}, other.size, 0u, 0u};
+
+   if (other.size > 0u) {
+      const std::size_t capacity = compute_capacity(0u, other.size);
+      res.data.reset(new char[capacity]);
+      res.capacity = capacity;
+      res.reallocs = 1u;
+      std::copy(other.data.get(), other.data.get() + other.size, res.data.get());
+   }
+
+   return res;
+}
+
+// Copy assignment
+inline void copy_assign(flat_buffer& buff, const flat_buffer& other)
+{
+   // Make space if required
+   if (buff.capacity < other.size) {
+      const std::size_t capacity = compute_capacity(buff.capacity, other.size);
+      buff.data.reset(new char[capacity]);
+      buff.capacity = capacity;
+      ++buff.reallocs;
+   }
+
+   // Copy the contents
+   std::copy(other.data.get(), other.data.get() + other.size, buff.data.get());
+   buff.size = other.size;
+}
+
+// Grows the buffer until reaching a target size.
+// Might rebase the strings in nodes
+inline void grow(flat_buffer& buff, std::size_t new_capacity, view_tree& nodes)
+{
+   if (new_capacity <= buff.capacity)
+      return;
+
+   // Compute the actual capacity that we will be using
+   new_capacity = compute_capacity(buff.capacity, new_capacity);
+
+   // Allocate space
+   std::unique_ptr<char[]> new_buffer{new char[new_capacity]};
+
+   // Copy any data into the newly allocated space
+   const char* data_before = buff.data.get();
+   char* data_after = new_buffer.get();
+   std::copy(data_before, data_before + buff.size, data_after);
+
+   // Update the string views so they don't dangle
+   rebase_strings(nodes, data_before, data_after);
+
+   // Replace the buffer. Note that size hasn't changed here
+   buff.data = std::move(new_buffer);
+   buff.capacity = new_capacity;
+   ++buff.reallocs;
+}
+
+// Appends a string to the buffer.
+// Might rebase the string in nodes, but doesn't append any new node.
+inline std::string_view append(flat_buffer& buff, std::string_view value, view_tree& nodes)
+{
+   // If there is nothing to copy, do nothing
+   if (value.empty())
+      return value;
+
+   // Make space for the new string
+   const std::size_t new_size = buff.size + value.size();
+   grow(buff, new_size, nodes);
+
+   // Copy the new value
+   const std::size_t offset = buff.size;
+   std::copy(value.data(), value.data() + value.size(), buff.data.get() + offset);
+   buff.size = new_size;
+   return {buff.data.get() + offset, value.size()};
+}
+
+}  // namespace detail
+
+flat_tree::flat_tree(flat_tree const& other)
+: data_{detail::copy_construct(other.data_)}
+, view_tree_{other.view_tree_}
+, total_msgs_{other.total_msgs_}
+{
+   detail::rebase_strings(view_tree_, other.data_.data.get(), data_.data.get());
+}
+
+flat_tree& flat_tree::operator=(const flat_tree& other)
+{
+   if (this != &other) {
+      // Copy the data
+      detail::copy_assign(data_, other.data_);
+
+      // Copy the nodes
+      view_tree_ = other.view_tree_;
+      detail::rebase_strings(view_tree_, other.data_.data.get(), data_.data.get());
+
+      // Copy the other fields
+      total_msgs_ = other.total_msgs_;
+   }
+
+   return *this;
+}
+
+void flat_tree::reserve(std::size_t bytes, std::size_t nodes)
+{
+   // Space for the strings
+   detail::grow(data_, bytes, view_tree_);
+
+   // Space for the nodes
+   view_tree_.reserve(nodes);
+}
+
+void flat_tree::clear() noexcept
+{
+   data_.size = 0u;
+   view_tree_.clear();
+   total_msgs_ = 0u;
+}
+
+void flat_tree::push(node_view const& nd)
+{
+   // Add the string
+   const std::string_view str = detail::append(data_, nd.value, view_tree_);
+
+   // Add the node
+   view_tree_.push_back({
+      nd.data_type,
+      nd.aggregate_size,
+      nd.depth,
+      str,
+   });
+}
+
+bool operator==(flat_tree const& a, flat_tree const& b)
+{
+   // data is already taken into account by comparing the nodes.
+   return a.view_tree_ == b.view_tree_ && a.total_msgs_ == b.total_msgs_;
+}
+
+}  // namespace boost::redis::resp3

include/boost/redis/impl/log_utils.hpp

@@ -7,6 +7,7 @@
 #ifndef BOOST_REDIS_LOG_UTILS_HPP
 #define BOOST_REDIS_LOG_UTILS_HPP
 
+#include <boost/redis/config.hpp>
 #include <boost/redis/logger.hpp>
 
 #include <boost/core/ignore_unused.hpp>
@@ -48,6 +49,16 @@ struct log_traits<system::error_code> {
    }
 };
 
+template <>
+struct log_traits<address> {
+   static inline void log(std::string& to, const address& value)
+   {
+      to += value.host;
+      to += ':';
+      to += value.port;
+   }
+};
+
 template <class... Args>
 void format_log_args(std::string& to, const Args&... args)
 {

include/boost/redis/impl/read_buffer.ipp

@@ -42,12 +42,13 @@ auto read_buffer::get_prepared() noexcept -> span_type
 
 auto read_buffer::get_commited() const noexcept -> std::string_view
 {
-   return {buffer_.data(), append_buf_begin_};
+   return {buffer_.data() + offset_, append_buf_begin_ - offset_};
 }
 
 void read_buffer::clear()
 {
    buffer_.clear();
+   offset_ = 0;
    append_buf_begin_ = 0;
 }
 
@@ -56,14 +57,22 @@ read_buffer::consume(std::size_t size)
 {
    // For convenience, if the requested size is larger than the
    // committed buffer we cap it to the maximum.
-   if (size > append_buf_begin_)
-      size = append_buf_begin_;
+   auto const consumable = append_buf_begin_ - offset_;
+   if (size > consumable)
+      size = consumable;
 
-   buffer_.erase(buffer_.begin(), buffer_.begin() + size);
-   auto const rotated = size == 0u ? 0u : buffer_.size();
+   offset_ += size;
+   BOOST_ASSERT(offset_ <= append_buf_begin_);
 
-   BOOST_ASSERT(append_buf_begin_ >= size);
-   append_buf_begin_ -= size;
+   auto rotated = 0u;
+   if (offset_ >= 10'000'000 && size > 0u) {
+      buffer_.erase(buffer_.begin(), buffer_.begin() + offset_);
+      rotated = buffer_.size();
+
+      BOOST_ASSERT(offset_ <= append_buf_begin_);
+      append_buf_begin_ -= offset_;
+      offset_ = 0u;
+   }
 
    return {size, rotated};
 }

include/boost/redis/impl/response.ipp

@@ -9,9 +9,13 @@
 
 #include <boost/assert.hpp>
 
+#include <algorithm>
+
 namespace boost::redis {
 
-void consume_one(generic_response& r, system::error_code& ec)
+namespace detail {
+
+inline void consume_one_impl(generic_response& r, system::error_code& ec)
 {
    if (r.has_error())
       return;  // Nothing to consume.
@@ -38,10 +42,14 @@ void consume_one(generic_response& r, system::error_code& ec)
    r.value().erase(std::cbegin(r.value()), match);
 }
 
+}  // namespace detail
+
+void consume_one(generic_response& r, system::error_code& ec) { detail::consume_one_impl(r, ec); }
+
 void consume_one(generic_response& r)
 {
    system::error_code ec;
-   consume_one(r, ec);
+   detail::consume_one_impl(r, ec);
    if (ec)
       throw system::system_error(ec);
 }

include/boost/redis/impl/run_fsm.ipp

@@ -8,12 +8,15 @@
 
 #include <boost/redis/adapter/any_adapter.hpp>
 #include <boost/redis/config.hpp>
+#include <boost/redis/detail/connect_params.hpp>
 #include <boost/redis/detail/connection_state.hpp>
 #include <boost/redis/detail/coroutine.hpp>
 #include <boost/redis/detail/multiplexer.hpp>
 #include <boost/redis/detail/run_fsm.hpp>
+#include <boost/redis/error.hpp>
 #include <boost/redis/impl/is_terminal_cancel.hpp>
 #include <boost/redis/impl/log_utils.hpp>
+#include <boost/redis/impl/sentinel_utils.hpp>
 #include <boost/redis/impl/setup_request_utils.hpp>
 
 #include <boost/asio/cancellation_type.hpp>
@@ -28,6 +31,8 @@ inline system::error_code check_config(const config& cfg)
    if (!cfg.unix_socket.empty()) {
       if (cfg.use_ssl)
          return error::unix_sockets_ssl_unsupported;
+      if (use_sentinel(cfg))
+         return error::sentinel_unix_sockets_unsupported;
 #ifndef BOOST_ASIO_HAS_LOCAL_SOCKETS
       return error::unix_sockets_unsupported;
 #endif
@@ -41,45 +46,44 @@ inline void compose_ping_request(const config& cfg, request& to)
    to.push("PING", cfg.health_check_id);
 }
 
-inline void process_setup_node(
-   connection_state& st,
-   resp3::basic_node<std::string_view> const& nd,
-   system::error_code& ec)
-{
-   switch (nd.data_type) {
-      case resp3::type::simple_error:
-      case resp3::type::blob_error:
-      case resp3::type::null:
-         ec = redis::error::resp3_hello;
-         st.setup_diagnostic = nd.value;
-         break;
-      default:;
-   }
-}
-
-inline any_adapter make_setup_adapter(connection_state& st)
-{
-   return any_adapter{
-      [&st](any_adapter::parse_event evt, resp3::node_view const& nd, system::error_code& ec) {
-         if (evt == any_adapter::parse_event::node)
-            process_setup_node(st, nd, ec);
-      }};
-}
-
 inline void on_setup_done(const multiplexer::elem& elm, connection_state& st)
 {
    const auto ec = elm.get_error();
    if (ec) {
-      if (st.setup_diagnostic.empty()) {
+      if (st.diagnostic.empty()) {
          log_info(st.logger, "Setup request execution: ", ec);
       } else {
-         log_info(st.logger, "Setup request execution: ", ec, " (", st.setup_diagnostic, ")");
+         log_info(st.logger, "Setup request execution: ", ec, " (", st.diagnostic, ")");
       }
    } else {
       log_info(st.logger, "Setup request execution: success");
    }
 }
 
+inline any_address_view get_server_address(const connection_state& st)
+{
+   if (st.cfg.unix_socket.empty()) {
+      return {st.cfg.addr, st.cfg.use_ssl};
+   } else {
+      return any_address_view{st.cfg.unix_socket};
+   }
+}
+
+template <>
+struct log_traits<any_address_view> {
+   static inline void log(std::string& to, any_address_view value)
+   {
+      if (value.type() == transport_type::unix_socket) {
+         to += '\'';
+         to += value.unix_socket();
+         to += '\'';
+      } else {
+         log_traits<address>::log(to, value.tcp_address());
+         to += value.type() == transport_type::tcp_tls ? " (TLS enabled)" : " (TLS disabled)";
+      }
+   }
+};
+
 run_action run_fsm::resume(
    connection_state& st,
    system::error_code ec,
@@ -103,9 +107,34 @@ run_action run_fsm::resume(
       // Compose the PING request. Same as above
       compose_ping_request(st.cfg, st.ping_req);
 
+      if (use_sentinel(st.cfg)) {
+         // Sentinel request. Same as above
+         compose_sentinel_request(st.cfg);
+
+         // Bootstrap the sentinel list with the ones configured by the user
+         st.sentinels = st.cfg.sentinel.addresses;
+      }
+
       for (;;) {
+         // Sentinel resolve, if required. This leaves the address in st.cfg.address
+         if (use_sentinel(st.cfg)) {
+            // This operation does the logging for us.
+            BOOST_REDIS_YIELD(resume_point_, 2, run_action_type::sentinel_resolve)
+
+            // Check for cancellations
+            if (is_terminal_cancel(cancel_state)) {
+               log_debug(st.logger, "Run: cancelled (4)");
+               return {asio::error::operation_aborted};
+            }
+
+            // Check for errors
+            if (ec)
+               goto sleep_and_reconnect;
+         }
+
          // Try to connect
-         BOOST_REDIS_YIELD(resume_point_, 2, run_action_type::connect)
+         log_info(st.logger, "Trying to connect to Redis server at ", get_server_address(st));
+         BOOST_REDIS_YIELD(resume_point_, 4, run_action_type::connect)
 
          // Check for cancellations
          if (is_terminal_cancel(cancel_state)) {
@@ -113,53 +142,66 @@ run_action run_fsm::resume(
             return system::error_code(asio::error::operation_aborted);
          }
 
-         // If we were successful, run all the connection tasks
-         if (!ec) {
-            // Initialization
-            st.mpx.reset();
-            st.setup_diagnostic.clear();
-
-            // Add the setup request to the multiplexer
-            if (st.cfg.setup.get_commands() != 0u) {
-               auto elm = make_elem(st.cfg.setup, make_setup_adapter(st));
-               elm->set_done_callback([&elem_ref = *elm, &st] {
-                  on_setup_done(elem_ref, st);
-               });
-               st.mpx.add(elm);
-            }
-
-            // Run the tasks
-            BOOST_REDIS_YIELD(resume_point_, 3, run_action_type::parallel_group)
-
-            // Store any error yielded by the tasks for later
-            stored_ec_ = ec;
-
-            // We've lost connection or otherwise been cancelled.
-            // Remove from the multiplexer the required requests.
-            st.mpx.cancel_on_conn_lost();
-
-            // The receive operation must be cancelled because channel
-            // subscription does not survive a reconnection but requires
-            // re-subscription.
-            BOOST_REDIS_YIELD(resume_point_, 4, run_action_type::cancel_receive)
-
-            // Restore the error
-            ec = stored_ec_;
+         if (ec) {
+            // There was an error. Skip to the reconnection loop
+            log_info(
+               st.logger,
+               "Failed to connect to Redis server at ",
+               get_server_address(st),
+               ": ",
+               ec);
+            goto sleep_and_reconnect;
          }
 
+         // We were successful
+         log_info(st.logger, "Connected to Redis server at ", get_server_address(st));
+
+         // Initialization
+         st.mpx.reset();
+         st.diagnostic.clear();
+
+         // Add the setup request to the multiplexer
+         if (st.cfg.setup.get_commands() != 0u) {
+            auto elm = make_elem(st.cfg.setup, make_any_adapter_impl(setup_adapter{st}));
+            elm->set_done_callback([&elem_ref = *elm, &st] {
+               on_setup_done(elem_ref, st);
+            });
+            st.mpx.add(elm);
+         }
+
+         // Run the tasks
+         BOOST_REDIS_YIELD(resume_point_, 5, run_action_type::parallel_group)
+
+         // Store any error yielded by the tasks for later
+         stored_ec_ = ec;
+
+         // We've lost connection or otherwise been cancelled.
+         // Remove from the multiplexer the required requests.
+         st.mpx.cancel_on_conn_lost();
+
+         // The receive operation must be cancelled because channel
+         // subscription does not survive a reconnection but requires
+         // re-subscription.
+         BOOST_REDIS_YIELD(resume_point_, 6, run_action_type::cancel_receive)
+
+         // Restore the error
+         ec = stored_ec_;
+
          // Check for cancellations
          if (is_terminal_cancel(cancel_state)) {
             log_debug(st.logger, "Run: cancelled (2)");
             return system::error_code(asio::error::operation_aborted);
          }
 
+sleep_and_reconnect:
+
          // If we are not going to try again, we're done
          if (st.cfg.reconnect_wait_interval.count() == 0) {
             return ec;
          }
 
          // Wait for the reconnection interval
-         BOOST_REDIS_YIELD(resume_point_, 5, run_action_type::wait_for_reconnection)
+         BOOST_REDIS_YIELD(resume_point_, 7, run_action_type::wait_for_reconnection)
 
          // Check for cancellations
          if (is_terminal_cancel(cancel_state)) {
@@ -174,4 +216,14 @@ run_action run_fsm::resume(
    return system::error_code();
 }
 
+connect_params make_run_connect_params(const connection_state& st)
+{
+   return {
+      get_server_address(st),
+      st.cfg.resolve_timeout,
+      st.cfg.connect_timeout,
+      st.cfg.ssl_handshake_timeout,
+   };
+}
+
 }  // namespace boost::redis::detail

include/boost/redis/impl/sentinel_resolve_fsm.ipp

@@ -0,0 +1,182 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_SENTINEL_RESOLVE_FSM_IPP
+#define BOOST_REDIS_SENTINEL_RESOLVE_FSM_IPP
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/connect_params.hpp>
+#include <boost/redis/detail/connection_state.hpp>
+#include <boost/redis/detail/coroutine.hpp>
+#include <boost/redis/detail/sentinel_resolve_fsm.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/impl/is_terminal_cancel.hpp>
+#include <boost/redis/impl/log_utils.hpp>
+#include <boost/redis/impl/sentinel_utils.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/assert.hpp>
+
+#include <cstddef>
+#include <random>
+#include <string_view>
+
+namespace boost::redis::detail {
+
+// Logs an error at info level, and also stores it in the state,
+// so it can be logged at error level if all Sentinels fail.
+template <class... Args>
+void log_sentinel_error(connection_state& st, std::size_t current_idx, const Args&... args)
+{
+   st.diagnostic += "\n  ";
+   std::size_t size_before = st.diagnostic.size();
+   format_log_args(st.diagnostic, "Sentinel at ", st.sentinels[current_idx], ": ", args...);
+   log_info(st.logger, std::string_view{st.diagnostic}.substr(size_before));
+}
+
+sentinel_action sentinel_resolve_fsm::resume(
+   connection_state& st,
+   system::error_code ec,
+   asio::cancellation_type_t cancel_state)
+{
+   switch (resume_point_) {
+      BOOST_REDIS_CORO_INITIAL
+
+      st.diagnostic.clear();
+
+      log_info(
+         st.logger,
+         "Trying to resolve the address of ",
+         st.cfg.sentinel.server_role == role::master ? "master" : "a replica of master",
+         " '",
+         st.cfg.sentinel.master_name,
+         "' using Sentinel");
+
+      // Try all Sentinels in order. Upon any errors, save the diagnostic and try with the next one.
+      // If none of them are available, print an error diagnostic and fail.
+      for (idx_ = 0u; idx_ < st.sentinels.size(); ++idx_) {
+         log_debug(st.logger, "Trying to contact Sentinel at ", st.sentinels[idx_]);
+
+         // Try to connect
+         BOOST_REDIS_YIELD(resume_point_, 1, st.sentinels[idx_])
+
+         // Check for cancellations
+         if (is_terminal_cancel(cancel_state)) {
+            log_debug(st.logger, "Sentinel resolve: cancelled (1)");
+            return system::error_code(asio::error::operation_aborted);
+         }
+
+         // Check for errors
+         if (ec) {
+            log_sentinel_error(st, idx_, "connection establishment error: ", ec);
+            continue;
+         }
+
+         // Execute the Sentinel request
+         log_debug(st.logger, "Executing Sentinel request at ", st.sentinels[idx_]);
+         st.sentinel_resp_nodes.clear();
+         BOOST_REDIS_YIELD(resume_point_, 2, sentinel_action::request())
+
+         // Check for cancellations
+         if (is_terminal_cancel(cancel_state)) {
+            log_debug(st.logger, "Sentinel resolve: cancelled (2)");
+            return system::error_code(asio::error::operation_aborted);
+         }
+
+         // Check for errors
+         if (ec) {
+            log_sentinel_error(st, idx_, "error while executing request: ", ec);
+            continue;
+         }
+
+         // Parse the response
+         sentinel_response resp;
+         ec = parse_sentinel_response(st.sentinel_resp_nodes, st.cfg.sentinel.server_role, resp);
+
+         if (ec) {
+            if (ec == error::resp3_simple_error || ec == error::resp3_blob_error) {
+               log_sentinel_error(st, idx_, "responded with an error: ", resp.diagnostic);
+            } else if (ec == error::resp3_null) {
+               log_sentinel_error(st, idx_, "doesn't know about the configured master");
+            } else {
+               log_sentinel_error(
+                  st,
+                  idx_,
+                  "error parsing response (maybe forgot to upgrade to RESP3?): ",
+                  ec);
+            }
+
+            continue;
+         }
+
+         // When asking for replicas, we might get no replicas
+         if (st.cfg.sentinel.server_role == role::replica && resp.replicas.empty()) {
+            log_sentinel_error(st, idx_, "the configured master has no replicas");
+            continue;
+         }
+
+         // Store the resulting address in a well-known place
+         if (st.cfg.sentinel.server_role == role::master) {
+            st.cfg.addr = resp.master_addr;
+         } else {
+            // Choose a random replica
+            std::uniform_int_distribution<std::size_t> dist{0u, resp.replicas.size() - 1u};
+            const auto idx = dist(st.eng.get());
+            st.cfg.addr = resp.replicas[idx];
+         }
+
+         // Sentinel knows about this master. Log and update our config
+         log_info(
+            st.logger,
+            "Sentinel at ",
+            st.sentinels[idx_],
+            " resolved the server address to ",
+            st.cfg.addr);
+
+         update_sentinel_list(st.sentinels, idx_, resp.sentinels, st.cfg.sentinel.addresses);
+
+         st.sentinel_resp_nodes.clear();  // reduce memory consumption
+         return system::error_code();
+      }
+
+      // No Sentinel resolved our address
+      log_err(
+         st.logger,
+         "Failed to resolve the address of ",
+         st.cfg.sentinel.server_role == role::master ? "master" : "a replica of master",
+         " '",
+         st.cfg.sentinel.master_name,
+         "'. Tried the following Sentinels:",
+         st.diagnostic);
+      return {error::sentinel_resolve_failed};
+   }
+
+   // We should never get here
+   BOOST_ASSERT(false);
+   return system::error_code();
+}
+
+connect_params make_sentinel_connect_params(const config& cfg, const address& addr)
+{
+   return {
+      any_address_view{addr, cfg.sentinel.use_ssl},
+      cfg.sentinel.resolve_timeout,
+      cfg.sentinel.connect_timeout,
+      cfg.sentinel.ssl_handshake_timeout,
+   };
+}
+
+any_adapter make_sentinel_adapter(connection_state& st)
+{
+   return any_adapter(st.sentinel_resp_nodes);
+}
+
+}  // namespace boost::redis::detail
+
+#endif

include/boost/redis/impl/sentinel_utils.hpp

@@ -0,0 +1,278 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_SENTINEL_UTILS_HPP
+#define BOOST_REDIS_SENTINEL_UTILS_HPP
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/type.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/core/span.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+#include <algorithm>
+
+namespace boost::redis::detail {
+
+// Returns true if Sentinel should be used
+inline bool use_sentinel(const config& cfg) { return !cfg.sentinel.addresses.empty(); }
+
+// Composes the request to send to Sentinel modifying cfg.sentinel.setup
+inline void compose_sentinel_request(config& cfg)
+{
+   // These commands should go after the user-supplied setup, as this might involve authentication.
+   // We ask for the master even when connecting to replicas to correctly detect when the master doesn't exist
+   cfg.sentinel.setup.push("SENTINEL", "GET-MASTER-ADDR-BY-NAME", cfg.sentinel.master_name);
+   if (cfg.sentinel.server_role == role::replica)
+      cfg.sentinel.setup.push("SENTINEL", "REPLICAS", cfg.sentinel.master_name);
+   cfg.sentinel.setup.push("SENTINEL", "SENTINELS", cfg.sentinel.master_name);
+
+   // Note that we don't care about request flags because this is a one-time request
+}
+
+// Parses a list of replicas or sentinels
+inline system::error_code parse_server_list(
+   const resp3::node*& first,
+   const resp3::node* last,
+   std::vector<address>& out)
+{
+   const auto* it = first;
+   ignore_unused(last);
+
+   // The root node must be an array
+   BOOST_ASSERT(it != last);
+   BOOST_ASSERT(it->depth == 0u);
+   if (it->data_type != resp3::type::array)
+      return {error::expects_resp3_array};
+   const std::size_t num_servers = it->aggregate_size;
+   ++it;
+
+   // Each element in the array represents a server
+   out.resize(num_servers);
+   for (std::size_t i = 0u; i < num_servers; ++i) {
+      // A server is a map (resp3) or array (resp2, currently unsupported)
+      BOOST_ASSERT(it != last);
+      BOOST_ASSERT(it->depth == 1u);
+      if (it->data_type != resp3::type::map)
+         return {error::expects_resp3_map};
+      const std::size_t num_key_values = it->aggregate_size;
+      ++it;
+
+      // The server object is composed by a set of key/value pairs.
+      // Skip everything except for the ones we care for.
+      bool ip_seen = false, port_seen = false;
+      for (std::size_t j = 0; j < num_key_values; ++j) {
+         // Key. It should be a string
+         BOOST_ASSERT(it != last);
+         BOOST_ASSERT(it->depth == 2u);
+         if (it->data_type != resp3::type::blob_string)
+            return {error::expects_resp3_string};
+         const std::string_view key = it->value;
+         ++it;
+
+         // Value. All values seem to be strings, too.
+         BOOST_ASSERT(it != last);
+         BOOST_ASSERT(it->depth == 2u);
+         if (it->data_type != resp3::type::blob_string)
+            return {error::expects_resp3_string};
+
+         // Record it
+         if (key == "ip") {
+            ip_seen = true;
+            out[i].host = it->value;
+         } else if (key == "port") {
+            port_seen = true;
+            out[i].port = it->value;
+         }
+
+         ++it;
+      }
+
+      // Check that the response actually contained the fields we wanted
+      if (!ip_seen || !port_seen)
+         return {error::empty_field};
+   }
+
+   // Done
+   first = it;
+   return system::error_code();
+}
+
+// The output type of parse_sentinel_response
+struct sentinel_response {
+   std::string diagnostic;         // In case the server returned an error
+   address master_addr;            // Always populated
+   std::vector<address> replicas;  // Populated only when connecting to replicas
+   std::vector<address> sentinels;
+};
+
+// Parses an array of nodes into a sentinel_response.
+// The request originating this response should be:
+//    <user-supplied commands, as per sentinel_config::setup>
+//    SENTINEL GET-MASTER-ADDR-BY-NAME
+//    SENTINEL REPLICAS (only if server_role is replica)
+//    SENTINEL SENTINELS
+// SENTINEL SENTINELS and SENTINEL REPLICAS error when the master name is unknown. Error nodes
+// should be allowed in the node array.
+// This means that we can't use generic_response, since its adapter errors on error nodes.
+// SENTINEL GET-MASTER-ADDR-BY-NAME is sent even when connecting to replicas
+//    for better diagnostics when the master name is unknown.
+// Preconditions:
+//   * There are at least 2 (master)/3 (replica) root nodes.
+//   * The node array originates from parsing a valid RESP3 message.
+//     E.g. we won't check that the first node has depth 0.
+inline system::error_code parse_sentinel_response(
+   span<const resp3::node> nodes,
+   role server_role,
+   sentinel_response& out)
+{
+   auto check_errors = [&out](const resp3::node& nd) {
+      switch (nd.data_type) {
+         case resp3::type::simple_error:
+            out.diagnostic = nd.value;
+            return system::error_code(error::resp3_simple_error);
+         case resp3::type::blob_error:
+            out.diagnostic = nd.value;
+            return system::error_code(error::resp3_blob_error);
+         default: return system::error_code();
+      }
+   };
+
+   // Clear the output
+   out.diagnostic.clear();
+   out.sentinels.clear();
+   out.replicas.clear();
+
+   // Find the first root node of interest. It's the 2nd or 3rd, starting with the end
+   auto find_first = [nodes, server_role] {
+      const std::size_t expected_roots = server_role == role::master ? 2u : 3u;
+      std::size_t roots_seen = 0u;
+      for (auto it = nodes.rbegin();; ++it) {
+         BOOST_ASSERT(it != nodes.rend());
+         if (it->depth == 0u && ++roots_seen == expected_roots)
+            return &*it;
+      }
+   };
+   const resp3::node* lib_first = find_first();
+
+   // Iterators
+   const resp3::node* it = nodes.begin();
+   const resp3::node* last = nodes.end();
+   ignore_unused(last);
+
+   // Go through all the responses to user-supplied requests checking for errors
+   for (; it != lib_first; ++it) {
+      if (auto ec = check_errors(*it))
+         return ec;
+   }
+
+   // SENTINEL GET-MASTER-ADDR-BY-NAME
+
+   // Check for errors
+   if (auto ec = check_errors(*it))
+      return ec;
+
+   // If the root node is NULL, Sentinel doesn't know about this master.
+   // We use resp3_null to signal this fact. This doesn't reach the end user.
+   if (it->data_type == resp3::type::null) {
+      return {error::resp3_null};
+   }
+
+   // If the root node is an array, an IP and port follow
+   if (it->data_type != resp3::type::array)
+      return {error::expects_resp3_array};
+   if (it->aggregate_size != 2u)
+      return {error::incompatible_size};
+   ++it;
+
+   // IP
+   BOOST_ASSERT(it != last);
+   BOOST_ASSERT(it->depth == 1u);
+   if (it->data_type != resp3::type::blob_string)
+      return {error::expects_resp3_string};
+   out.master_addr.host = it->value;
+   ++it;
+
+   // Port
+   BOOST_ASSERT(it != last);
+   BOOST_ASSERT(it->depth == 1u);
+   if (it->data_type != resp3::type::blob_string)
+      return {error::expects_resp3_string};
+   out.master_addr.port = it->value;
+   ++it;
+
+   if (server_role == role::replica) {
+      // SENTINEL REPLICAS
+
+      // This request fails if Sentinel doesn't know about this master.
+      // However, that's not the case if we got here.
+      // Check for other errors.
+      if (auto ec = check_errors(*it))
+         return ec;
+
+      // Actual parsing
+      if (auto ec = parse_server_list(it, last, out.replicas))
+         return ec;
+   }
+
+   // SENTINEL SENTINELS
+
+   // This request fails if Sentinel doesn't know about this master.
+   // However, that's not the case if we got here.
+   // Check for other errors.
+   if (auto ec = check_errors(*it))
+      return ec;
+
+   // Actual parsing
+   if (auto ec = parse_server_list(it, last, out.sentinels))
+      return ec;
+
+   // Done
+   return system::error_code();
+}
+
+// Updates the internal Sentinel list.
+// to should never be empty
+inline void update_sentinel_list(
+   std::vector<address>& to,
+   std::size_t current_index,               // the one to maintain and place first
+   span<const address> gossip_sentinels,    // the ones that SENTINEL SENTINELS returned
+   span<const address> bootstrap_sentinels  // the ones the user supplied
+)
+{
+   BOOST_ASSERT(!to.empty());
+
+   // Remove everything, except the Sentinel that succeeded
+   if (current_index != 0u)
+      std::swap(to.front(), to[current_index]);
+   to.resize(1u);
+
+   // Add one group. These Sentinels are always unique and don't include the one we're currently connected to.
+   to.insert(to.end(), gossip_sentinels.begin(), gossip_sentinels.end());
+
+   // Insert any user-supplied sentinels, if not already present.
+   // This is O(n^2), but is okay because n will be small.
+   // The list can't be sorted, anyway
+   for (const auto& sentinel : bootstrap_sentinels) {
+      if (std::find(to.begin(), to.end(), sentinel) == to.end())
+         to.push_back(sentinel);
+   }
+}
+
+}  // namespace boost::redis::detail
+
+#endif

include/boost/redis/impl/setup_request_utils.hpp

@@ -8,19 +8,27 @@
 #define BOOST_REDIS_SETUP_REQUEST_UTILS_HPP
 
 #include <boost/redis/config.hpp>
+#include <boost/redis/detail/connection_state.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/impl/sentinel_utils.hpp>  // use_sentinel
 #include <boost/redis/request.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/type.hpp>
 #include <boost/redis/response.hpp>
 
+#include <cstddef>
+
 namespace boost::redis::detail {
 
 // Modifies config::setup to make a request suitable to be sent
 // to the server using async_exec
 inline void compose_setup_request(config& cfg)
 {
+   auto& req = cfg.setup;
+
    if (!cfg.use_setup) {
       // We're not using the setup request as-is, but should compose one based on
       // the values passed by the user
-      auto& req = cfg.setup;
       req.clear();
 
       // Which parts of the command should we send?
@@ -46,14 +54,71 @@ inline void compose_setup_request(config& cfg)
          req.push("SELECT", cfg.database_index.value());
    }
 
+   // When using Sentinel, we should add a role check.
+   // This must happen after the other commands, as it requires authentication.
+   if (use_sentinel(cfg))
+      req.push("ROLE");
+
    // In any case, the setup request should have the priority
    // flag set so it's executed before any other request.
    // The setup request should never be retried.
-   request_access::set_priority(cfg.setup, true);
-   cfg.setup.get_config().cancel_if_unresponded = true;
-   cfg.setup.get_config().cancel_on_connection_lost = true;
+   request_access::set_priority(req, true);
+   req.get_config().cancel_if_unresponded = true;
+   req.get_config().cancel_on_connection_lost = true;
 }
 
+class setup_adapter {
+   connection_state* st_;
+   std::size_t response_idx_{0u};
+   bool role_seen_{false};
+
+   system::error_code on_node_impl(const resp3::node_view& nd)
+   {
+      // An error node is always an error
+      switch (nd.data_type) {
+         case resp3::type::simple_error:
+         case resp3::type::blob_error:   st_->diagnostic = nd.value; return error::resp3_hello;
+         default:                        ;
+      }
+
+      // When using Sentinel, we add a ROLE command at the end.
+      // We need to ensure that this instance is a master.
+      if (use_sentinel(st_->cfg) && response_idx_ == st_->cfg.setup.get_expected_responses() - 1u) {
+         // ROLE's response should be an array of at least 1 element
+         if (nd.depth == 0u) {
+            if (nd.data_type != resp3::type::array)
+               return error::invalid_data_type;
+            if (nd.aggregate_size == 0u)
+               return error::incompatible_size;
+         }
+
+         // The first node should be 'master' if we're connecting to a primary,
+         // 'slave' if we're connecting to a replica
+         if (nd.depth == 1u && !role_seen_) {
+            role_seen_ = true;
+            if (nd.data_type != resp3::type::blob_string)
+               return error::invalid_data_type;
+
+            const char* expected_role = st_->cfg.sentinel.server_role == role::master ? "master"
+                                                                                      : "slave";
+            if (nd.value != expected_role)
+               return error::role_check_failed;
+         }
+      }
+
+      return system::error_code();
+   }
+
+public:
+   explicit setup_adapter(connection_state& st) noexcept
+   : st_(&st)
+   { }
+
+   void on_init() { }
+   void on_done() { ++response_idx_; }
+   void on_node(const resp3::node_view& node, system::error_code& ec) { ec = on_node_impl(node); }
+};
+
 }  // namespace boost::redis::detail
 
 #endif  // BOOST_REDIS_RUNNER_HPP

include/boost/redis/request.hpp

@@ -10,7 +10,6 @@
 #include <boost/redis/resp3/serialization.hpp>
 #include <boost/redis/resp3/type.hpp>
 
-#include <algorithm>
 #include <string>
 #include <tuple>
 
@@ -34,11 +33,9 @@ struct request_access;
  *
  *  @code
  *  request r;
- *  r.push("HELLO", 3);
- *  r.push("FLUSHALL");
- *  r.push("PING");
- *  r.push("PING", "key");
- *  r.push("QUIT");
+ *  r.push("SET", "k1", "some_value");
+ *  r.push("SET", "k2", "other_value");
+ *  r.push("GET", "k3");
  *  @endcode
  *
  *  Uses a `std::string` for internal storage.
@@ -146,14 +143,14 @@ public:
     *
     *  @code
     *  request req;
-    *  req.push("SET", "key", "some string", "EX", "2");
+    *  req.push("SET", "key", "some string", "EX", 2);
     *  @endcode
     *
     *  This will add a `SET` command with value `"some string"` and an
     *  expiration of 2 seconds.
     *
-    *  Command arguments should either be convertible to `std::string_view`
-    *  or support the `boost_redis_to_bulk` function.
+    *  Command arguments should either be convertible to `std::string_view`,
+    *  integral types, or support the `boost_redis_to_bulk` function.
     *  This function is a customization point that must be made available
     *  using ADL and must have the following signature:
     *
@@ -165,7 +162,7 @@ public:
     *  See cpp20_serialization.cpp
     *
     *  @param cmd The command to execute. It should be a redis or sentinel command, like `"SET"`.
-    *  @param args Command arguments. Non-string types will be converted to string by calling `boost_redis_to_bulk` on each argument.
+    *  @param args Command arguments. `args` is allowed to be empty.
     *  @tparam Ts Types of the command arguments.
     *
     */
@@ -196,21 +193,36 @@ public:
     *  req.push_range("HSET", "key", map.cbegin(), map.cend());
     *  @endcode
     *
-    *  Command arguments should either be convertible to `std::string_view`
-    *  or support the `boost_redis_to_bulk` function.
-    *  This function is a customization point that must be made available
-    *  using ADL and must have the following signature:
+    *  This will generate the following command:
     *
     *  @code
-    *  void boost_redis_to_bulk(std::string& to, T const& t);
+    *  HSET key key1 value1 key2 value2 key3 value3
     *  @endcode
-    *  
+    *
+    *  *If the passed range is empty, no command is added* and this
+    *  function becomes a no-op.
+    *
+    *  The value type of the passed range should satisfy one of the following:
+    *
+    *    @li The type is convertible to `std::string_view`. One argument is added
+    *        per element in the range.
+    *    @li The type is an integral type. One argument is added
+    *        per element in the range.
+    *    @li The type supports the `boost_redis_to_bulk` function. One argument is added
+    *        per element in the range. This function is a customization point that must be made available
+    *        using ADL and must have the signature `void boost_redis_to_bulk(std::string& to, T const& t);`.
+    *    @li The type is a `std::pair` instantiation, with both arguments supporting one of
+    *        the points above. Two arguments are added per element in the range.
+    *        Nested pairs are not allowed.
+    *    @li The type is a `std::tuple` instantiation, with every argument supporting
+    *        one of the points above. N arguments are added per element in the range,
+    *        with N being the tuple size. Nested tuples are not allowed. 
+    *        
     *  @param cmd The command to execute. It should be a redis or sentinel command, like `"SET"`.
     *  @param key The command key. It will be added as the first argument to the command.
     *  @param begin Iterator to the begin of the range.
     *  @param end Iterator to the end of the range.
-    *  @tparam ForwardIterator A forward iterator with an element type that is convertible to `std::string_view`
-    *          or supports `boost_redis_to_bulk`.
+    *  @tparam ForwardIterator A forward iterator with an element type that supports one of the points above.
     *
     *  See cpp20_serialization.cpp
     */
@@ -249,23 +261,38 @@ public:
     *     { "channel1" , "channel2" , "channel3" };
     *
     *  request req;
-    *  req.push("SUBSCRIBE", std::cbegin(channels), std::cend(channels));
+    *  req.push("SUBSCRIBE", channels.cbegin(), channels.cend());
     *  @endcode
     *
-    *  Command arguments should either be convertible to `std::string_view`
-    *  or support the `boost_redis_to_bulk` function.
-    *  This function is a customization point that must be made available
-    *  using ADL and must have the following signature:
+    *  This will generate the following command:
     *
     *  @code
-    *  void boost_redis_to_bulk(std::string& to, T const& t);
+    *  SUBSCRIBE channel1 channel2 channel3
     *  @endcode
+    *
+    *  *If the passed range is empty, no command is added* and this
+    *  function becomes a no-op.
+    *
+    *  The value type of the passed range should satisfy one of the following:
+    *
+    *    @li The type is convertible to `std::string_view`. One argument is added
+    *        per element in the range.
+    *    @li The type is an integral type. One argument is added
+    *        per element in the range.
+    *    @li The type supports the `boost_redis_to_bulk` function. One argument is added
+    *        per element in the range. This function is a customization point that must be made available
+    *        using ADL and must have the signature `void boost_redis_to_bulk(std::string& to, T const& t);`.
+    *    @li The type is a `std::pair` instantiation, with both arguments supporting one of
+    *        the points above. Two arguments are added per element in the range.
+    *        Nested pairs are not allowed.
+    *    @li The type is a `std::tuple` instantiation, with every argument supporting
+    *        one of the points above. N arguments are added per element in the range,
+    *        with N being the tuple size. Nested tuples are not allowed.
     *  
     *  @param cmd The command to execute. It should be a redis or sentinel command, like `"SET"`.
     *  @param begin Iterator to the begin of the range.
     *  @param end Iterator to the end of the range.
-    *  @tparam ForwardIterator A forward iterator with an element type that is convertible to `std::string_view`
-    *          or supports `boost_redis_to_bulk`.
+    *  @tparam ForwardIterator A forward iterator with an element type that supports one of the points above.
     *
     *  See cpp20_serialization.cpp
     */
@@ -296,13 +323,31 @@ public:
     *  
     *  Equivalent to the overload taking a range of begin and end
     *  iterators.
+    *
+    *  *If the passed range is empty, no command is added* and this
+    *  function becomes a no-op.
+    *
+    *  The value type of the passed range should satisfy one of the following:
+    *
+    *    @li The type is convertible to `std::string_view`. One argument is added
+    *        per element in the range.
+    *    @li The type is an integral type. One argument is added
+    *        per element in the range.
+    *    @li The type supports the `boost_redis_to_bulk` function. One argument is added
+    *        per element in the range. This function is a customization point that must be made available
+    *        using ADL and must have the signature `void boost_redis_to_bulk(std::string& to, T const& t);`.
+    *    @li The type is a `std::pair` instantiation, with both arguments supporting one of
+    *        the points above. Two arguments are added per element in the range.
+    *        Nested pairs are not allowed.
+    *    @li The type is a `std::tuple` instantiation, with every argument supporting
+    *        one of the points above. N arguments are added per element in the range,
+    *        with N being the tuple size. Nested tuples are not allowed.
     *  
     *  @param cmd The command to execute. It should be a redis or sentinel command, like `"SET"`.
     *  @param key The command key. It will be added as the first argument to the command.
     *  @param range Range containing the command arguments.
     *  @tparam Range A type that can be passed to `std::begin()` and `std::end()` to obtain
-    *          iterators. The range elements should be convertible to `std::string_view`
-    *          or support `boost_redis_to_bulk`.
+    *          iterators.
     */
    template <class Range>
    void push_range(
@@ -320,12 +365,30 @@ public:
     *
     *  Equivalent to the overload taking a range of begin and end
     *  iterators.
+    *
+    *  *If the passed range is empty, no command is added* and this
+    *  function becomes a no-op.
+    *
+    *  The value type of the passed range should satisfy one of the following:
+    *
+    *    @li The type is convertible to `std::string_view`. One argument is added
+    *        per element in the range.
+    *    @li The type is an integral type. One argument is added
+    *        per element in the range.
+    *    @li The type supports the `boost_redis_to_bulk` function. One argument is added
+    *        per element in the range. This function is a customization point that must be made available
+    *        using ADL and must have the signature `void boost_redis_to_bulk(std::string& to, T const& t);`.
+    *    @li The type is a `std::pair` instantiation, with both arguments supporting one of
+    *        the points above. Two arguments are added per element in the range.
+    *        Nested pairs are not allowed.
+    *    @li The type is a `std::tuple` instantiation, with every argument supporting
+    *        one of the points above. N arguments are added per element in the range,
+    *        with N being the tuple size. Nested tuples are not allowed.
     *  
     *  @param cmd The command to execute. It should be a redis or sentinel command, like `"SET"`.
     *  @param range Range containing the command arguments.
     *  @tparam Range A type that can be passed to `std::begin()` and `std::end()` to obtain
-    *          iterators. The range elements should be convertible to `std::string_view`
-    *          or support `boost_redis_to_bulk`.
+    *          iterators.
     */
    template <class Range>
    void push_range(

include/boost/redis/resp3/flat_tree.hpp

@@ -0,0 +1,252 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Nikolai Vladimirov (nvladimirov.work@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_REDIS_RESP3_FLAT_TREE_HPP
+#define BOOST_REDIS_RESP3_FLAT_TREE_HPP
+
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/tree.hpp>
+
+#include <cstddef>
+#include <memory>
+
+namespace boost::redis {
+
+namespace adapter::detail {
+template <class> class general_aggregate;
+}  // namespace adapter::detail
+
+namespace resp3 {
+
+namespace detail {
+
+struct flat_buffer {
+   std::unique_ptr<char[]> data;
+   std::size_t size = 0u;
+   std::size_t capacity = 0u;
+   std::size_t reallocs = 0u;
+};
+
+}  // namespace detail
+
+/** @brief A generic response that stores data contiguously.
+ *
+ * Implements a container of RESP3 nodes. It's similar to @ref boost::redis::resp3::tree,
+ * but node data is stored contiguously. This allows for amortized no allocations
+ * when re-using `flat_tree` objects. Like `tree`, it can contain the response
+ * to several Redis commands or several server pushes. Use @ref get_total_msgs
+ * to obtain how many responses this object contains.
+ *
+ * Objects are typically created by the user and passed to @ref connection::async_exec
+ * to be used as response containers. Call @ref get_view to access the actual RESP3 nodes.
+ * Once populated, `flat_tree` can't be modified, except for @ref clear and assignment.
+ *
+ * A `flat_tree` is conceptually similar to a pair of `std::vector` objects, one holding
+ * @ref resp3::node_view objects, and another owning the the string data that these views
+ * point to. The node capacity and the data capacity are the capacities of these two vectors.
+ */
+class flat_tree {
+public:
+   /**
+    * @brief Default constructor.
+    *
+    * Constructs an empty tree, with no nodes, zero node capacity and zero data capacity.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    */
+   flat_tree() = default;
+
+   /**
+    * @brief Move constructor.
+    *
+    * Constructs a tree by taking ownership of the nodes in `other`.
+    *
+    * @par Object lifetimes
+    * References to the nodes and strings in `other` remain valid.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    */
+   flat_tree(flat_tree&& other) noexcept = default;
+
+   /**
+    * @brief Copy constructor.
+    *
+    * Constructs a tree by copying the nodes in `other`. After the copy,
+    * `*this` and `other` have independent lifetimes (usual copy semantics).
+    *
+    * @par Exception safety
+    * Strong guarantee. Memory allocations might throw.
+    */
+   flat_tree(flat_tree const& other);
+
+   /**
+    * @brief Move assignment.
+    *
+    * Replaces the nodes in `*this` by taking ownership of the nodes in `other`.
+    * `other` is left in a valid but unspecified state.
+    *
+    * @par Object lifetimes
+    * References to the nodes and strings in `other` remain valid.
+    * References to the nodes and strings in `*this` are invalidated.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    */
+   flat_tree& operator=(flat_tree&& other) = default;
+
+   /**
+    * @brief Copy assignment.
+    *
+    * Replaces the nodes in `*this` by copying the nodes in `other`.
+    * After the copy, `*this` and `other` have independent lifetimes (usual copy semantics).
+    *
+    * @par Object lifetimes
+    * References to the nodes and strings in `*this` are invalidated.
+    *
+    * @par Exception safety
+    * Basic guarantee. Memory allocations might throw.
+    */
+   flat_tree& operator=(const flat_tree& other);
+
+   friend bool operator==(flat_tree const&, flat_tree const&);
+
+   friend bool operator!=(flat_tree const&, flat_tree const&);
+
+   /** @brief Reserves capacity for incoming data.
+    *
+    * Adding nodes (e.g. by passing the tree to `async_exec`)
+    * won't cause reallocations until the data or node capacities
+    * are exceeded, following the usual vector semantics.
+    * The implementation might reserve more capacity than the one requested.
+    * 
+    * @par Object lifetimes
+    * References to the nodes and strings in `*this` are invalidated.
+    *
+    * @par Exception safety
+    * Basic guarantee. Memory allocations might throw.
+    *
+    * @param bytes Number of bytes to reserve for data.
+    * @param nodes Number of nodes to reserve.
+    */
+   void reserve(std::size_t bytes, std::size_t nodes);
+
+   /** @brief Clears the tree so it contains no nodes.
+    * 
+    * Calling this function removes every node, making
+    * @ref get_view return empty and @ref get_total_msgs
+    * return zero. It does not modify the object's capacity.
+    * 
+    * To re-use a `flat_tree` for several requests,
+    * use `clear()` before each `async_exec` call.
+    *
+    * @par Object lifetimes
+    * References to the nodes and strings in `*this` are invalidated.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    */
+   void clear() noexcept;
+
+   /** @brief Returns the size of the data buffer, in bytes.
+    * 
+    * You may use this function to calculate how much capacity
+    * should be reserved for data when calling @ref reserve.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    *
+    * @returns The number of bytes in use in the data buffer.
+    */
+   auto data_size() const noexcept -> std::size_t { return data_.size; }
+
+   /** @brief Returns the capacity of the data buffer, in bytes.
+    *
+    * Note that the actual capacity of the data buffer may be bigger
+    * than the one requested by @ref reserve.
+    *
+    * @par Exception safety
+    * No-throw guarantee. 
+    *
+    * @returns The capacity of the data buffer, in bytes.
+    */
+   auto data_capacity() const noexcept -> std::size_t { return data_.capacity; }
+
+   /** @brief Returns a vector with the nodes in the tree.
+    *
+    * This is the main way to access the contents of the tree.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    *
+    * @returns The nodes in the tree.
+    */
+   auto get_view() const noexcept -> view_tree const& { return view_tree_; }
+
+   /** @brief Returns the number of memory reallocations that took place in the data buffer.
+    *
+    * This function returns how many reallocations in the data buffer were performed and
+    * can be useful to determine how much memory to reserve upfront.
+    * 
+    * @par Exception safety
+    * No-throw guarantee.
+    *
+    * @returns The number of times that the data buffer reallocated its memory.
+    */
+   auto get_reallocs() const noexcept -> std::size_t { return data_.reallocs; }
+
+   /** @brief Returns the number of complete RESP3 messages contained in this object.
+    *
+    * This value is equal to the number of nodes in the tree with a depth of zero.
+    *
+    * @par Exception safety
+    * No-throw guarantee.
+    *
+    * @returns The number of complete RESP3 messages contained in this object.
+    */
+   std::size_t get_total_msgs() const noexcept { return total_msgs_; }
+
+private:
+   template <class> friend class adapter::detail::general_aggregate;
+
+   void notify_done() { ++total_msgs_; }
+
+   // Push a new node to the response
+   void push(node_view const& node);
+
+   detail::flat_buffer data_;
+   view_tree view_tree_;
+   std::size_t total_msgs_ = 0u;
+};
+
+/**
+ * @brief Equality operator.
+ * @relates flat_tree
+ *
+ * Two trees are equal if they contain the same nodes in the same order.
+ * Capacities are not taken into account.
+ *
+ * @par Exception safety
+ * No-throw guarantee.
+ */
+bool operator==(flat_tree const&, flat_tree const&);
+
+/**
+ * @brief Inequality operator.
+ * @relates flat_tree
+ *
+ * @par Exception safety
+ * No-throw guarantee.
+ */
+inline bool operator!=(flat_tree const& lhs, flat_tree const& rhs) { return !(lhs == rhs); }
+
+}  // namespace resp3
+}  // namespace boost::redis
+
+#endif  // BOOST_REDIS_RESP3_FLAT_TREE_HPP

include/boost/redis/resp3/impl/type.ipp

@@ -8,6 +8,8 @@
 
 #include <boost/assert.hpp>
 
+#include <ostream>
+
 namespace boost::redis::resp3 {
 
 auto to_string(type t) noexcept -> char const*

include/boost/redis/resp3/node.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -9,6 +9,10 @@
 
 #include <boost/redis/resp3/type.hpp>
 
+#include <cstddef>
+#include <string>
+#include <string_view>
+
 namespace boost::redis::resp3 {
 
 /** @brief A node in the response tree.
@@ -43,7 +47,7 @@ struct basic_node {
  *  @param b Right hand side node object.
  */
 template <class String>
-auto operator==(basic_node<String> const& a, basic_node<String> const& b)
+bool operator==(basic_node<String> const& a, basic_node<String> const& b)
 {
    // clang-format off
    return a.aggregate_size == b.aggregate_size
@@ -53,6 +57,18 @@ auto operator==(basic_node<String> const& a, basic_node<String> const& b)
    // clang-format on
 };
 
+/** @brief Inequality operator for RESP3 nodes.
+ *  @relates basic_node
+ *
+ *  @param a Left hand side node object.
+ *  @param b Right hand side node object.
+ */
+template <class String>
+bool operator!=(basic_node<String> const& a, basic_node<String> const& b)
+{
+   return !(a == b);
+};
+
 /// A node in the response tree that owns its data.
 using node = basic_node<std::string>;
 

include/boost/redis/resp3/parser.hpp

@@ -12,7 +12,6 @@
 #include <boost/system/error_code.hpp>
 
 #include <array>
-#include <cstdint>
 #include <optional>
 #include <string_view>
 

include/boost/redis/resp3/serialization.hpp

@@ -16,9 +16,6 @@
 #include <string>
 #include <tuple>
 
-// NOTE: Consider detecting tuples in the type in the parameter pack
-// to calculate the header size correctly.
-
 namespace boost::redis::resp3 {
 
 /** @brief Adds a bulk to the request.
@@ -35,6 +32,10 @@ namespace boost::redis::resp3 {
  *  }
  *  @endcode
  *
+ *  The function must add exactly one bulk string RESP3 node.
+ *  If you're using `boost_redis_to_bulk` with a string argument,
+ *  you're safe.
+ *
  *  @param payload Storage on which data will be copied into.
  *  @param data Data that will be serialized and stored in `payload`.
  */
@@ -100,6 +101,11 @@ struct bulk_counter<std::pair<T, U>> {
    static constexpr auto size = 2U;
 };
 
+template <class... T>
+struct bulk_counter<std::tuple<T...>> {
+   static constexpr auto size = sizeof...(T);
+};
+
 void add_blob(std::string& payload, std::string_view blob);
 void add_separator(std::string& payload);
 

include/boost/redis/resp3/tree.hpp

@@ -0,0 +1,29 @@
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_RESP3_TREE_HPP
+#define BOOST_REDIS_RESP3_TREE_HPP
+
+#include <boost/redis/resp3/node.hpp>
+
+#include <vector>
+#include <string_view>
+
+namespace boost::redis::resp3 {
+
+/// A RESP3 tree that owns its data.
+template <class String, class Allocator = std::allocator<basic_node<String>>>
+using basic_tree = std::vector<basic_node<String>, Allocator>;
+
+/// A RESP3 tree that owns its data.
+using tree = basic_tree<std::string>;
+
+/// A RESP3 tree whose data are `std::string_views`.
+using view_tree = basic_tree<std::string_view>;
+
+}
+
+#endif  // BOOST_REDIS_RESP3_RESPONSE_HPP

include/boost/redis/resp3/type.hpp

@@ -9,9 +9,8 @@
 
 #include <boost/assert.hpp>
 
-#include <ostream>
-#include <string>
-#include <vector>
+#include <cstddef>
+#include <iosfwd>
 
 namespace boost::redis::resp3 {
 

include/boost/redis/response.hpp

@@ -8,13 +8,13 @@
 #define BOOST_REDIS_RESPONSE_HPP
 
 #include <boost/redis/adapter/result.hpp>
+#include <boost/redis/resp3/flat_tree.hpp>
 #include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/tree.hpp>
 
 #include <boost/system/error_code.hpp>
 
-#include <string>
 #include <tuple>
-#include <vector>
 
 namespace boost::redis {
 
@@ -29,9 +29,12 @@ using response = std::tuple<adapter::result<Ts>...>;
  *  [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
  *  view of the response tree.
  */
-using generic_response = adapter::result<std::vector<resp3::node>>;
+using generic_response = adapter::result<resp3::tree>;
 
-/** @brief Consume on response from a generic response
+/// Similar to @ref boost::redis::generic_response but stores data contiguously.
+using generic_flat_response = adapter::result<resp3::flat_tree>;
+
+/** @brief (Deprecated) Consume on response from a generic response
  *
  *  This function rotates the elements so that the start of the next
  *  response becomes the new front element. For example the output of
@@ -70,13 +73,15 @@ using generic_response = adapter::result<std::vector<resp3::node>>;
  * @param r The response to modify.
  * @param ec Will be populated in case of error.
  */
+BOOST_DEPRECATED("This function is not needed anymore to consume server pushes.")
 void consume_one(generic_response& r, system::error_code& ec);
 
 /**
- * @brief Throwing overload of `consume_one`.
+ * @brief (Deprecated) Throwing overload of `consume_one`.
  *
  * @param r The response to modify.
  */
+BOOST_DEPRECATED("This function is not needed anymore to consume server pushes.")
 void consume_one(generic_response& r);
 
 }  // namespace boost::redis

include/boost/redis/src.hpp

@@ -8,6 +8,7 @@
 #include <boost/redis/impl/connection.ipp>
 #include <boost/redis/impl/error.ipp>
 #include <boost/redis/impl/exec_fsm.ipp>
+#include <boost/redis/impl/exec_one_fsm.ipp>
 #include <boost/redis/impl/ignore.ipp>
 #include <boost/redis/impl/logger.ipp>
 #include <boost/redis/impl/multiplexer.ipp>
@@ -16,7 +17,9 @@
 #include <boost/redis/impl/request.ipp>
 #include <boost/redis/impl/response.ipp>
 #include <boost/redis/impl/run_fsm.ipp>
+#include <boost/redis/impl/sentinel_resolve_fsm.ipp>
 #include <boost/redis/impl/writer_fsm.ipp>
+#include <boost/redis/impl/flat_tree.ipp>
 #include <boost/redis/resp3/impl/parser.ipp>
 #include <boost/redis/resp3/impl/serialization.ipp>
 #include <boost/redis/resp3/impl/type.ipp>

test/CMakeLists.txt

@@ -35,17 +35,25 @@ endmacro()
 # Unit tests
 make_test(test_low_level)
 make_test(test_request)
+make_test(test_serialization)
 make_test(test_low_level_sync_sans_io)
 make_test(test_any_adapter)
-make_test(test_exec_fsm)
 make_test(test_log_to_file)
 make_test(test_conn_logging)
+make_test(test_exec_fsm)
+make_test(test_exec_one_fsm)
 make_test(test_writer_fsm)
 make_test(test_reader_fsm)
 make_test(test_connect_fsm)
+make_test(test_sentinel_resolve_fsm)
 make_test(test_run_fsm)
-make_test(test_setup_request_utils)
+make_test(test_compose_setup_request)
+make_test(test_setup_adapter)
 make_test(test_multiplexer)
+make_test(test_parse_sentinel_response)
+make_test(test_update_sentinel_list)
+make_test(test_flat_tree)
+make_test(test_read_buffer)
 
 # Tests that require a real Redis server
 make_test(test_conn_quit)
@@ -56,6 +64,7 @@ make_test(test_conn_run_cancel)
 make_test(test_conn_check_health)
 make_test(test_conn_exec)
 make_test(test_conn_push)
+make_test(test_conn_push2)
 make_test(test_conn_monitor)
 make_test(test_conn_reconnect)
 make_test(test_conn_exec_cancel)
@@ -67,6 +76,7 @@ make_test(test_conversions)
 make_test(test_conn_tls)
 make_test(test_unix_sockets)
 make_test(test_conn_cancel_after)
+make_test(test_conn_sentinel)
 
 # Coverage
 set(

test/Jamfile

@@ -52,17 +52,25 @@ lib redis_test_common
 local tests =
     test_low_level
     test_request
+    test_serialization
     test_low_level_sync_sans_io
     test_any_adapter
-    test_exec_fsm
     test_log_to_file
     test_conn_logging
+    test_exec_fsm
+    test_exec_one_fsm
     test_writer_fsm
     test_reader_fsm
+    test_sentinel_resolve_fsm
     test_run_fsm
     test_connect_fsm
-    test_setup_request_utils
+    test_compose_setup_request
+    test_setup_adapter
     test_multiplexer
+    test_parse_sentinel_response
+    test_update_sentinel_list
+    test_flat_tree
+    test_read_buffer
 ;
 
 # Build and run the tests

test/common.cpp

@@ -1,11 +1,16 @@
+#include <boost/redis/config.hpp>
+#include <boost/redis/ignore.hpp>
+
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/consign.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include "common.hpp"
 
 #include <cstdlib>
 #include <iostream>
 #include <stdexcept>
+#include <string_view>
 
 namespace net = boost::asio;
 
@@ -71,7 +76,6 @@ void run_coroutine_test(net::awaitable<void> op, std::chrono::steady_clock::dura
 
 // Finds a value in the output of the CLIENT INFO command
 // format: key1=value1 key2=value2
-// TODO: duplicated
 std::string_view find_client_info(std::string_view client_info, std::string_view key)
 {
    std::string prefix{key};
@@ -84,3 +88,45 @@ std::string_view find_client_info(std::string_view client_info, std::string_view
    auto const pos_end = client_info.find(' ', pos_begin);
    return client_info.substr(pos_begin, pos_end - pos_begin);
 }
+
+void create_user(std::string_view port, std::string_view username, std::string_view password)
+{
+   // Setup
+   net::io_context ioc;
+   boost::redis::connection conn{ioc};
+
+   boost::redis::config cfg;
+   cfg.addr.port = port;
+
+   // Enable the user and grant them permissions on everything
+   boost::redis::request req;
+   req.push("ACL", "SETUSER", username, "on", ">" + std::string(password), "~*", "&*", "+@all");
+
+   bool run_finished = false, exec_finished = false;
+
+   conn.async_run(cfg, [&](boost::system::error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   conn.async_exec(req, boost::redis::ignore, [&](boost::system::error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, boost::system::error_code());
+      conn.cancel();
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(run_finished);
+   BOOST_TEST(exec_finished);
+}
+
+boost::redis::logger make_string_logger(std::string& to)
+{
+   return {
+      boost::redis::logger::level::info,
+      [&to](boost::redis::logger::level, std::string_view msg) {
+         to += msg;
+         to += '\n';
+      }};
+}

test/common.hpp

@@ -2,6 +2,7 @@
 
 #include <boost/redis/connection.hpp>
 #include <boost/redis/detail/reader_fsm.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/redis/operation.hpp>
 
 #include <boost/asio/awaitable.hpp>
@@ -11,6 +12,7 @@
 
 #include <chrono>
 #include <memory>
+#include <string>
 #include <string_view>
 
 // The timeout for tests involving communication to a real server.
@@ -40,3 +42,8 @@ void run(
 // Finds a value in the output of the CLIENT INFO command
 // format: key1=value1 key2=value2
 std::string_view find_client_info(std::string_view client_info, std::string_view key);
+
+// Connects to the Redis server at the given port and creates a user
+void create_user(std::string_view port, std::string_view username, std::string_view password);
+
+boost::redis::logger make_string_logger(std::string& to);

test/print_node.hpp

@@ -0,0 +1,28 @@
+
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_TEST_PRINT_NODE_HPP
+#define BOOST_REDIS_TEST_PRINT_NODE_HPP
+
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/type.hpp>
+
+#include <ostream>
+
+namespace boost::redis::resp3 {
+
+template <class String>
+std::ostream& operator<<(std::ostream& os, basic_node<String> const& nd)
+{
+   return os << "node{ .data_type=" << to_string(nd.data_type)
+             << ", .aggregate_size=" << nd.aggregate_size << ", .depth=" << nd.depth
+             << ", .value=" << nd.value << "}";
+}
+
+}  // namespace boost::redis::resp3
+
+#endif  // BOOST_REDIS_TEST_SANSIO_UTILS_HPP

test/sansio_utils.cpp

@@ -4,8 +4,10 @@
  * accompanying file LICENSE.txt)
  */
 
+#include <boost/redis/adapter/any_adapter.hpp>
 #include <boost/redis/detail/multiplexer.hpp>
 
+#include <boost/assert/source_location.hpp>
 #include <boost/core/ignore_unused.hpp>
 #include <boost/core/lightweight_test.hpp>
 
@@ -72,4 +74,24 @@ logger log_fixture::make_logger()
    });
 }
 
+std::vector<resp3::node> nodes_from_resp3(
+   const std::vector<std::string_view>& msgs,
+   source_location loc)
+{
+   std::vector<resp3::node> nodes;
+   any_adapter adapter{nodes};
+
+   for (std::string_view resp : msgs) {
+      resp3::parser p;
+      system::error_code ec;
+      bool done = resp3::parse(p, resp, adapter, ec);
+      if (!BOOST_TEST(done))
+         std::cerr << "Called from " << loc << std::endl;
+      if (!BOOST_TEST_EQ(ec, system::error_code()))
+         std::cerr << "Called from " << loc << std::endl;
+   }
+
+   return nodes;
+}
+
 }  // namespace boost::redis::detail

test/sansio_utils.hpp

@@ -8,6 +8,7 @@
 #define BOOST_REDIS_TEST_SANSIO_UTILS_HPP
 
 #include <boost/redis/logger.hpp>
+#include <boost/redis/resp3/node.hpp>
 
 #include <boost/assert/source_location.hpp>
 
@@ -15,6 +16,7 @@
 #include <initializer_list>
 #include <string>
 #include <string_view>
+#include <vector>
 
 namespace boost::redis::detail {
 
@@ -50,6 +52,13 @@ constexpr auto to_milliseconds(std::chrono::steady_clock::duration d)
    return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
 }
 
+// Creates a vector of nodes from a set of RESP3 messages.
+// Using the raw RESP values ensures that the correct
+// node tree is built, which is not always obvious
+std::vector<resp3::node> nodes_from_resp3(
+   const std::vector<std::string_view>& msgs,
+   source_location loc = BOOST_CURRENT_LOCATION);
+
 }  // namespace boost::redis::detail
 
 #endif  // BOOST_REDIS_TEST_SANSIO_UTILS_HPP

test/test_any_adapter.cpp

@@ -13,6 +13,7 @@
 #include <boost/test/included/unit_test.hpp>
 
 using boost::redis::generic_response;
+using boost::redis::resp3::flat_tree;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::any_adapter;
@@ -24,10 +25,12 @@ BOOST_AUTO_TEST_CASE(any_adapter_response_types)
    response<int> r1;
    response<int, std::string> r2;
    generic_response r3;
+   flat_tree r4;
 
    BOOST_CHECK_NO_THROW(any_adapter{r1});
    BOOST_CHECK_NO_THROW(any_adapter{r2});
    BOOST_CHECK_NO_THROW(any_adapter{r3});
+   BOOST_CHECK_NO_THROW(any_adapter{r4});
    BOOST_CHECK_NO_THROW(any_adapter{ignore});
 }
 

test/test_compose_setup_request.cpp

@@ -25,7 +25,7 @@ using boost::system::error_code;
 
 namespace {
 
-void test_compose_setup()
+void test_hello()
 {
    redis::config cfg;
    cfg.clientname = "";
@@ -39,7 +39,7 @@ void test_compose_setup()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_select()
+void test_select()
 {
    redis::config cfg;
    cfg.clientname = "";
@@ -56,7 +56,7 @@ void test_compose_setup_select()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_clientname()
+void test_clientname()
 {
    redis::config cfg;
 
@@ -70,7 +70,7 @@ void test_compose_setup_clientname()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_auth()
+void test_auth()
 {
    redis::config cfg;
    cfg.clientname = "";
@@ -87,7 +87,7 @@ void test_compose_setup_auth()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_auth_empty_password()
+void test_auth_empty_password()
 {
    redis::config cfg;
    cfg.clientname = "";
@@ -103,7 +103,7 @@ void test_compose_setup_auth_empty_password()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_auth_setname()
+void test_auth_setname()
 {
    redis::config cfg;
    cfg.clientname = "mytest";
@@ -121,7 +121,7 @@ void test_compose_setup_auth_setname()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
-void test_compose_setup_use_setup()
+void test_use_setup()
 {
    redis::config cfg;
    cfg.clientname = "mytest";
@@ -143,7 +143,7 @@ void test_compose_setup_use_setup()
 }
 
 // Regression check: we set the priority flag
-void test_compose_setup_use_setup_no_hello()
+void test_use_setup_no_hello()
 {
    redis::config cfg;
    cfg.use_setup = true;
@@ -160,7 +160,7 @@ void test_compose_setup_use_setup_no_hello()
 }
 
 // Regression check: we set the relevant cancellation flags in the request
-void test_compose_setup_use_setup_flags()
+void test_use_setup_flags()
 {
    redis::config cfg;
    cfg.use_setup = true;
@@ -178,19 +178,65 @@ void test_compose_setup_use_setup_flags()
    BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
 }
 
+// When using Sentinel, a ROLE command is added. This works
+// both with the old HELLO and new setup strategies.
+void test_sentinel_auth()
+{
+   redis::config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   cfg.clientname = "";
+   cfg.username = "foo";
+   cfg.password = "bar";
+
+   compose_setup_request(cfg);
+
+   std::string_view const expected =
+      "*5\r\n$5\r\nHELLO\r\n$1\r\n3\r\n$4\r\nAUTH\r\n$3\r\nfoo\r\n$3\r\nbar\r\n"
+      "*1\r\n$4\r\nROLE\r\n";
+   BOOST_TEST_EQ(cfg.setup.payload(), expected);
+   BOOST_TEST(cfg.setup.has_hello_priority());
+   BOOST_TEST(cfg.setup.get_config().cancel_if_unresponded);
+   BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
+}
+
+void test_sentinel_use_setup()
+{
+   redis::config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   cfg.use_setup = true;
+   cfg.setup.push("SELECT", 42);
+
+   compose_setup_request(cfg);
+
+   std::string_view const expected =
+      "*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n"
+      "*2\r\n$6\r\nSELECT\r\n$2\r\n42\r\n"
+      "*1\r\n$4\r\nROLE\r\n";
+   BOOST_TEST_EQ(cfg.setup.payload(), expected);
+   BOOST_TEST(cfg.setup.has_hello_priority());
+   BOOST_TEST(cfg.setup.get_config().cancel_if_unresponded);
+   BOOST_TEST(cfg.setup.get_config().cancel_on_connection_lost);
+}
+
 }  // namespace
 
 int main()
 {
-   test_compose_setup();
-   test_compose_setup_select();
-   test_compose_setup_clientname();
-   test_compose_setup_auth();
-   test_compose_setup_auth_empty_password();
-   test_compose_setup_auth_setname();
-   test_compose_setup_use_setup();
-   test_compose_setup_use_setup_no_hello();
-   test_compose_setup_use_setup_flags();
+   test_hello();
+   test_select();
+   test_clientname();
+   test_auth();
+   test_auth_empty_password();
+   test_auth_setname();
+   test_use_setup();
+   test_use_setup_no_hello();
+   test_use_setup_flags();
+   test_sentinel_auth();
+   test_sentinel_use_setup();
 
    return boost::report_errors();
 }

test/test_conn_echo_stress.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -27,6 +27,7 @@ using error_code = boost::system::error_code;
 using boost::redis::operation;
 using boost::redis::request;
 using boost::redis::response;
+using boost::redis::resp3::flat_tree;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::logger;
@@ -54,39 +55,44 @@ std::ostream& operator<<(std::ostream& os, usage const& u)
 
 namespace {
 
-auto push_consumer(connection& conn, int expected) -> net::awaitable<void>
+auto
+receiver(
+   connection& conn,
+   flat_tree& resp,
+   std::size_t expected) -> net::awaitable<void>
 {
-   int c = 0;
-   for (error_code ec;;) {
-      conn.receive(ec);
-      if (ec == error::sync_receive_push_failed) {
-         ec = {};
-         co_await conn.async_receive(net::redirect_error(ec));
-      } else if (!ec) {
-         //std::cout << "Skipping suspension." << std::endl;
-      }
-
-      if (ec) {
-         BOOST_TEST(false, "push_consumer error: " << ec.message());
-         co_return;
-      }
-      if (++c == expected)
-         break;
+   std::size_t push_counter = 0;
+   while (push_counter != expected) {
+      co_await conn.async_receive2();
+      push_counter += resp.get_total_msgs();
+      resp.clear();
    }
 
    conn.cancel();
 }
 
-auto echo_session(connection& conn, const request& pubs, int n) -> net::awaitable<void>
+auto echo_session(connection& conn, const request& req, std::size_t n) -> net::awaitable<void>
 {
-   for (auto i = 0; i < n; ++i)
-      co_await conn.async_exec(pubs);
+   for (auto i = 0u; i < n; ++i)
+      co_await conn.async_exec(req);
 }
 
 void rethrow_on_error(std::exception_ptr exc)
 {
-   if (exc)
+   if (exc) {
+      BOOST_TEST(false);
       std::rethrow_exception(exc);
+   }
+}
+
+request make_pub_req(std::size_t n_pubs)
+{
+   request req;
+   req.push("PING");
+   for (std::size_t i = 0u; i < n_pubs; ++i)
+      req.push("PUBLISH", "channel", "payload");
+
+   return req;
 }
 
 BOOST_AUTO_TEST_CASE(echo_stress)
@@ -98,22 +104,22 @@ BOOST_AUTO_TEST_CASE(echo_stress)
 
    // Number of coroutines that will send pings sharing the same
    // connection to redis.
-   constexpr int sessions = 150;
+   constexpr std::size_t sessions = 150u;
 
    // The number of pings that will be sent by each session.
-   constexpr int msgs = 200;
+   constexpr std::size_t msgs = 200u;
 
    // The number of publishes that will be sent by each session with
    // each message.
-   constexpr int n_pubs = 25;
+   constexpr std::size_t n_pubs = 25u;
 
    // This is the total number of pushes we will receive.
-   constexpr int total_pushes = sessions * msgs * n_pubs + 1;
+   constexpr std::size_t total_pushes = sessions * msgs * n_pubs + 1;
 
-   request pubs;
-   pubs.push("PING");
-   for (int i = 0; i < n_pubs; ++i)
-      pubs.push("PUBLISH", "channel", "payload");
+   flat_tree resp;
+   conn.set_receive_response(resp);
+
+   request const pub_req = make_pub_req(n_pubs);
 
    // Run the connection
    bool run_finished = false, subscribe_finished = false;
@@ -123,6 +129,10 @@ BOOST_AUTO_TEST_CASE(echo_stress)
       std::clog << "async_run finished" << std::endl;
    });
 
+   // Op that will consume the pushes counting down until all expected
+   // pushes have been received.
+   net::co_spawn(ctx, receiver(conn, resp, total_pushes), rethrow_on_error);
+
    // Subscribe, then launch the coroutines
    request req;
    req.push("SUBSCRIBE", "channel");
@@ -130,12 +140,8 @@ BOOST_AUTO_TEST_CASE(echo_stress)
       subscribe_finished = true;
       BOOST_TEST(ec == error_code());
 
-      // Op that will consume the pushes counting down until all expected
-      // pushes have been received.
-      net::co_spawn(ctx, push_consumer(conn, total_pushes), rethrow_on_error);
-
-      for (int i = 0; i < sessions; ++i)
-         net::co_spawn(ctx, echo_session(conn, pubs, msgs), rethrow_on_error);
+      for (std::size_t i = 0; i < sessions; ++i)
+         net::co_spawn(ctx, echo_session(conn, pub_req, msgs), rethrow_on_error);
    });
 
    // Run the test
@@ -144,7 +150,13 @@ BOOST_AUTO_TEST_CASE(echo_stress)
    BOOST_TEST(subscribe_finished);
 
    // Print statistics
-   std::cout << "-------------------\n" << conn.get_usage() << std::endl;
+   std::cout
+      << "-------------------\n"
+      << "Usage data: \n"
+      << conn.get_usage() << "\n"
+      << "-------------------\n"
+      << "Reallocations: " << resp.get_reallocs()
+      << std::endl;
 }
 
 }  // namespace

test/test_conn_exec_error.cpp

@@ -269,9 +269,9 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
    generic_response gresp;
    conn->set_receive_response(gresp);
 
-   auto c3 = [&](error_code ec, std::size_t) {
+   auto c3 = [&](error_code ec) {
       c3_called = true;
-      std::cout << "async_receive" << std::endl;
+      std::cout << "async_receive2" << std::endl;
       BOOST_TEST(!ec);
       BOOST_TEST(gresp.has_error());
       BOOST_CHECK_EQUAL(gresp.error().data_type, resp3::type::simple_error);
@@ -281,7 +281,7 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
       conn->cancel(operation::reconnection);
    };
 
-   conn->async_receive(c3);
+   conn->async_receive2(c3);
 
    run(conn);
 
@@ -326,4 +326,4 @@ BOOST_AUTO_TEST_CASE(issue_287_generic_response_error_then_success)
    BOOST_TEST(resp.error().diagnostic == "ERR wrong number of arguments for 'set' command");
 }
 
-}  // namespace
+}  // namespace

test/test_conn_monitor.cpp

@@ -41,7 +41,7 @@ class test_monitor {
 
    void start_receive()
    {
-      conn.async_receive([this](error_code ec, std::size_t) {
+      conn.async_receive2([this](error_code ec) {
          // We should expect one push entry, at least
          BOOST_TEST_EQ(ec, error_code());
          BOOST_TEST(monitor_resp.has_value());
@@ -118,4 +118,4 @@ int main()
    test_monitor{}.run();
 
    return boost::report_errors();
-}
+}

test/test_conn_push2.cpp

@@ -0,0 +1,392 @@
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/redis/logger.hpp>
+#include <boost/redis/request.hpp>
+#include <boost/redis/response.hpp>
+
+#include <boost/asio/experimental/channel_error.hpp>
+#include <boost/system/errc.hpp>
+
+#include <string>
+
+#define BOOST_TEST_MODULE conn_push
+#include <boost/test/included/unit_test.hpp>
+
+#include "common.hpp"
+
+#include <cstddef>
+#include <iostream>
+
+namespace net = boost::asio;
+namespace redis = boost::redis;
+
+using boost::redis::operation;
+using boost::redis::connection;
+using boost::system::error_code;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::resp3::flat_tree;
+using boost::redis::ignore;
+using boost::redis::ignore_t;
+using boost::system::error_code;
+using boost::redis::logger;
+using namespace std::chrono_literals;
+
+namespace {
+
+BOOST_AUTO_TEST_CASE(receives_push_waiting_resps)
+{
+   request req1;
+   req1.push("HELLO", 3);
+   req1.push("PING", "Message1");
+
+   request req2;
+   req2.push("SUBSCRIBE", "channel");
+
+   request req3;
+   req3.push("PING", "Message2");
+   req3.push("QUIT");
+
+   net::io_context ioc;
+
+   auto conn = std::make_shared<connection>(ioc);
+
+   bool push_received = false, c1_called = false, c2_called = false, c3_called = false;
+
+   auto c3 = [&](error_code ec, std::size_t) {
+      c3_called = true;
+      std::cout << "c3: " << ec.message() << std::endl;
+   };
+
+   auto c2 = [&, conn](error_code ec, std::size_t) {
+      c2_called = true;
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req3, ignore, c3);
+   };
+
+   auto c1 = [&, conn](error_code ec, std::size_t) {
+      c1_called = true;
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c2);
+   };
+
+   conn->async_exec(req1, ignore, c1);
+
+   run(conn, make_test_config(), {});
+
+   conn->async_receive2([&, conn](error_code ec) {
+      std::cout << "async_receive2" << std::endl;
+      BOOST_TEST(ec == error_code());
+      push_received = true;
+      conn->cancel();
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(push_received);
+   BOOST_TEST(c1_called);
+   BOOST_TEST(c2_called);
+   BOOST_TEST(c3_called);
+}
+
+BOOST_AUTO_TEST_CASE(push_received1)
+{
+   net::io_context ioc;
+   auto conn = std::make_shared<connection>(ioc);
+
+   flat_tree resp;
+   conn->set_receive_response(resp);
+
+   // Trick: Uses SUBSCRIBE because this command has no response or
+   // better said, its response is a server push, which is what we
+   // want to test.
+   request req;
+   req.push("SUBSCRIBE", "channel1");
+   req.push("SUBSCRIBE", "channel2");
+
+   bool push_received = false, exec_finished = false;
+
+   conn->async_exec(req, ignore, [&, conn](error_code ec, std::size_t) {
+      exec_finished = true;
+      std::cout << "async_exec" << std::endl;
+      BOOST_TEST(ec == error_code());
+   });
+
+   conn->async_receive2([&, conn](error_code ec) {
+      push_received = true;
+      std::cout << "async_receive2" << std::endl;
+
+      BOOST_TEST(ec == error_code());
+
+      BOOST_CHECK_EQUAL(resp.get_total_msgs(), 2u);
+
+      conn->cancel();
+   });
+
+   run(conn);
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(push_received);
+}
+
+BOOST_AUTO_TEST_CASE(push_filtered_out)
+{
+   net::io_context ioc;
+   auto conn = std::make_shared<connection>(ioc);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("PING");
+   req.push("SUBSCRIBE", "channel");
+   req.push("QUIT");
+
+   response<ignore_t, std::string, std::string> resp;
+
+   bool exec_finished = false, push_received = false;
+
+   conn->async_exec(req, resp, [conn, &exec_finished](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST(ec == error_code());
+   });
+
+   conn->async_receive2([&, conn](error_code ec) {
+      push_received = true;
+      BOOST_TEST(ec == error_code());
+      conn->cancel(operation::reconnection);
+   });
+
+   run(conn);
+
+   ioc.run_for(test_timeout);
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(push_received);
+
+   BOOST_CHECK_EQUAL(std::get<1>(resp).value(), "PONG");
+   BOOST_CHECK_EQUAL(std::get<2>(resp).value(), "OK");
+}
+
+struct response_error_tag { };
+response_error_tag error_tag_obj;
+
+struct response_error_adapter {
+   void on_init() { }
+   void on_done() { }
+
+   void on_node(
+      boost::redis::resp3::basic_node<std::string_view> const&,
+      boost::system::error_code& ec)
+   {
+      ec = boost::redis::error::incompatible_size;
+   }
+};
+
+auto boost_redis_adapt(response_error_tag&) { return response_error_adapter{}; }
+
+BOOST_AUTO_TEST_CASE(test_push_adapter)
+{
+   net::io_context ioc;
+   auto conn = std::make_shared<connection>(ioc);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("PING");
+   req.push("SUBSCRIBE", "channel");
+   req.push("PING");
+
+   conn->set_receive_response(error_tag_obj);
+
+   bool push_received = false, exec_finished = false, run_finished = false;
+
+   conn->async_receive2([&, conn](error_code ec) {
+      BOOST_CHECK_EQUAL(ec, boost::asio::experimental::error::channel_cancelled);
+      push_received = true;
+   });
+
+   conn->async_exec(req, ignore, [&exec_finished](error_code ec, std::size_t) {
+      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
+      exec_finished = true;
+   });
+
+   auto cfg = make_test_config();
+   cfg.reconnect_wait_interval = 0s;
+   conn->async_run(cfg, [&run_finished](error_code ec) {
+      BOOST_CHECK_EQUAL(ec, redis::error::incompatible_size);
+      run_finished = true;
+   });
+
+   ioc.run_for(test_timeout);
+   BOOST_TEST(push_received);
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+
+   // TODO: Reset the ioc reconnect and send a quit to ensure
+   // reconnection is possible after an error.
+}
+
+void launch_push_consumer(std::shared_ptr<connection> conn)
+{
+   conn->async_receive2([conn](error_code ec) {
+      if (ec) {
+         BOOST_TEST(ec == net::experimental::error::channel_cancelled);
+         return;
+      }
+      launch_push_consumer(conn);
+   });
+}
+
+BOOST_AUTO_TEST_CASE(many_subscribers)
+{
+   request req0;
+   req0.get_config().cancel_on_connection_lost = false;
+   req0.push("HELLO", 3);
+
+   request req1;
+   req1.get_config().cancel_on_connection_lost = false;
+   req1.push("PING", "Message1");
+
+   request req2;
+   req2.get_config().cancel_on_connection_lost = false;
+   req2.push("SUBSCRIBE", "channel");
+
+   request req3;
+   req3.get_config().cancel_on_connection_lost = false;
+   req3.push("QUIT");
+
+   net::io_context ioc;
+   auto conn = std::make_shared<connection>(ioc);
+
+   bool finished = false;
+
+   auto c11 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->cancel(operation::reconnection);
+      finished = true;
+   };
+   auto c10 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req3, ignore, c11);
+   };
+   auto c9 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c10);
+   };
+   auto c8 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req1, ignore, c9);
+   };
+   auto c7 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c8);
+   };
+   auto c6 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c7);
+   };
+   auto c5 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req1, ignore, c6);
+   };
+   auto c4 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c5);
+   };
+   auto c3 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req1, ignore, c4);
+   };
+   auto c2 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c3);
+   };
+   auto c1 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req2, ignore, c2);
+   };
+   auto c0 = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      conn->async_exec(req1, ignore, c1);
+   };
+
+   conn->async_exec(req0, ignore, c0);
+   launch_push_consumer(conn);
+
+   run(conn, make_test_config(), {});
+
+   ioc.run_for(test_timeout);
+   BOOST_TEST(finished);
+}
+
+BOOST_AUTO_TEST_CASE(test_unsubscribe)
+{
+   net::io_context ioc;
+   connection conn{ioc};
+
+   // Subscribe to 3 channels and 2 patterns. Use CLIENT INFO to verify this took effect
+   request req_subscribe;
+   req_subscribe.push("SUBSCRIBE", "ch1", "ch2", "ch3");
+   req_subscribe.push("PSUBSCRIBE", "ch1*", "ch2*");
+   req_subscribe.push("CLIENT", "INFO");
+
+   // Then, unsubscribe from some of them, and verify again
+   request req_unsubscribe;
+   req_unsubscribe.push("UNSUBSCRIBE", "ch1");
+   req_unsubscribe.push("PUNSUBSCRIBE", "ch2*");
+   req_unsubscribe.push("CLIENT", "INFO");
+
+   // Finally, ping to verify that the connection is still usable
+   request req_ping;
+   req_ping.push("PING", "test_unsubscribe");
+
+   response<std::string> resp_subscribe, resp_unsubscribe, resp_ping;
+
+   bool subscribe_finished = false, unsubscribe_finished = false, ping_finished = false,
+        run_finished = false;
+
+   auto on_ping = [&](error_code ec, std::size_t) {
+      BOOST_TEST(ec == error_code());
+      ping_finished = true;
+      BOOST_TEST(std::get<0>(resp_ping).has_value());
+      BOOST_TEST(std::get<0>(resp_ping).value() == "test_unsubscribe");
+      conn.cancel();
+   };
+
+   auto on_unsubscribe = [&](error_code ec, std::size_t) {
+      unsubscribe_finished = true;
+      BOOST_TEST(ec == error_code());
+      BOOST_TEST(std::get<0>(resp_unsubscribe).has_value());
+      BOOST_TEST(find_client_info(std::get<0>(resp_unsubscribe).value(), "sub") == "2");
+      BOOST_TEST(find_client_info(std::get<0>(resp_unsubscribe).value(), "psub") == "1");
+      conn.async_exec(req_ping, resp_ping, on_ping);
+   };
+
+   auto on_subscribe = [&](error_code ec, std::size_t) {
+      subscribe_finished = true;
+      BOOST_TEST(ec == error_code());
+      BOOST_TEST(std::get<0>(resp_subscribe).has_value());
+      BOOST_TEST(find_client_info(std::get<0>(resp_subscribe).value(), "sub") == "3");
+      BOOST_TEST(find_client_info(std::get<0>(resp_subscribe).value(), "psub") == "2");
+      conn.async_exec(req_unsubscribe, resp_unsubscribe, on_unsubscribe);
+   };
+
+   conn.async_exec(req_subscribe, resp_subscribe, on_subscribe);
+
+   conn.async_run(make_test_config(), [&run_finished](error_code ec) {
+      BOOST_TEST(ec == net::error::operation_aborted);
+      run_finished = true;
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(subscribe_finished);
+   BOOST_TEST(unsubscribe_finished);
+   BOOST_TEST(ping_finished);
+   BOOST_TEST(run_finished);
+}
+
+}  // namespace

test/test_conn_sentinel.cpp

@@ -0,0 +1,491 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/connection.hpp>
+#include <boost/redis/ignore.hpp>
+#include <boost/redis/request.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/tree.hpp>
+#include <boost/redis/resp3/type.hpp>
+#include <boost/redis/response.hpp>
+
+#include <boost/asio/ssl/context.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#include "common.hpp"
+#include "print_node.hpp"
+
+#include <string>
+
+namespace net = boost::asio;
+using namespace boost::redis;
+using namespace std::chrono_literals;
+using boost::system::error_code;
+
+namespace {
+
+// We can execute requests normally when using Sentinel run
+void test_exec()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+      {"localhost", "26380"},
+      {"localhost", "26381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+
+   // Verify that we're connected to the master
+   request req;
+   req.push("ROLE");
+
+   generic_response resp;
+
+   bool exec_finished = false, run_finished = false;
+
+   conn.async_exec(req, resp, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, error_code());
+
+      // ROLE outputs an array, 1st element should be 'master'
+      BOOST_TEST(resp.has_value());
+      BOOST_TEST_GE(resp.value().size(), 2u);
+      BOOST_TEST_EQ(resp.value().at(1u).value, "master");
+
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+}
+
+// We can use receive normally when using Sentinel run
+void test_receive()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+      {"localhost", "26380"},
+      {"localhost", "26381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+
+   resp3::tree resp;
+   conn.set_receive_response(resp);
+
+   // Subscribe to a channel. This produces a push message on itself
+   request req;
+   req.push("SUBSCRIBE", "sentinel_channel");
+
+   bool exec_finished = false, receive_finished = false, run_finished = false;
+
+   conn.async_exec(req, resp, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, error_code());
+   });
+
+   conn.async_receive2([&](error_code ec2) {
+      receive_finished = true;
+      BOOST_TEST_EQ(ec2, error_code());
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(receive_finished);
+   BOOST_TEST(run_finished);
+
+   // We subscribed to channel 'sentinel_channel', and have 1 active subscription
+   const resp3::node expected[] = {
+      {resp3::type::push,        3u, 0u, ""                },
+      {resp3::type::blob_string, 1u, 1u, "subscribe"       },
+      {resp3::type::blob_string, 1u, 1u, "sentinel_channel"},
+      {resp3::type::number,      1u, 1u, "1"               },
+   };
+
+   BOOST_TEST_ALL_EQ(resp.begin(), resp.end(), std::begin(expected), std::end(expected));
+}
+
+// If connectivity to the Redis master fails, we can reconnect
+void test_reconnect()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+      {"localhost", "26380"},
+      {"localhost", "26381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+
+   // Will cause the connection to fail
+   request req_quit;
+   req_quit.push("QUIT");
+
+   // Will succeed if the reconnection succeeds
+   request req_ping;
+   req_ping.push("PING", "sentinel_reconnect");
+   req_ping.get_config().cancel_if_unresponded = false;
+
+   bool quit_finished = false, ping_finished = false, run_finished = false;
+
+   conn.async_exec(req_quit, ignore, [&](error_code ec1, std::size_t) {
+      quit_finished = true;
+      BOOST_TEST_EQ(ec1, error_code());
+      conn.async_exec(req_ping, ignore, [&](error_code ec2, std::size_t) {
+         ping_finished = true;
+         BOOST_TEST_EQ(ec2, error_code());
+         conn.cancel();
+      });
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(quit_finished);
+   BOOST_TEST(ping_finished);
+   BOOST_TEST(run_finished);
+}
+
+// If a Sentinel is not reachable, we try the next one
+void test_sentinel_not_reachable()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "45678"}, // invalid
+      {"localhost", "26381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+
+   // Verify that we're connected to the master, listening at port 6380
+   request req;
+   req.push("PING", "test_sentinel_not_reachable");
+
+   bool exec_finished = false, run_finished = false;
+
+   conn.async_exec(req, ignore, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, error_code());
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+}
+
+// Both Sentinels and masters may be protected with authorization
+void test_auth()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+   cfg.sentinel.setup.push("HELLO", 3, "AUTH", "sentinel_user", "sentinel_pass");
+
+   cfg.use_setup = true;
+   cfg.setup.clear();
+   cfg.setup.push("HELLO", 3, "AUTH", "redis_user", "redis_pass");
+
+   // Verify that we're authenticated correctly
+   request req;
+   req.push("ACL", "WHOAMI");
+
+   response<std::string> resp;
+
+   bool exec_finished = false, run_finished = false;
+
+   conn.async_exec(req, resp, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, error_code());
+      BOOST_TEST(std::get<0>(resp).has_value());
+      BOOST_TEST_EQ(std::get<0>(resp).value(), "redis_user");
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+}
+
+// TLS might be used with Sentinels. In our setup, nodes don't use TLS,
+// but this setting is independent from Sentinel.
+void test_tls()
+{
+   // Setup
+   net::io_context ioc;
+   net::ssl::context ssl_ctx{net::ssl::context::tlsv13_client};
+
+   // The custom server uses a certificate signed by a CA
+   // that is not trusted by default - skip verification.
+   ssl_ctx.set_verify_mode(net::ssl::verify_none);
+
+   connection conn{ioc, std::move(ssl_ctx)};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "36379"},
+      {"localhost", "36380"},
+      {"localhost", "36381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+   cfg.sentinel.use_ssl = true;
+
+   request req;
+   req.push("PING", "test_sentinel_tls");
+
+   bool exec_finished = false, run_finished = false;
+
+   conn.async_exec(req, ignore, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST(ec == error_code());
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, {}, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST(ec == net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+}
+
+// We can also connect to replicas
+void test_replica()
+{
+   // Setup
+   net::io_context ioc;
+   connection conn{ioc};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"},
+      {"localhost", "26380"},
+      {"localhost", "26381"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+   cfg.sentinel.server_role = role::replica;
+
+   // Verify that we're connected to a replica
+   request req;
+   req.push("ROLE");
+
+   generic_response resp;
+
+   bool exec_finished = false, run_finished = false;
+
+   conn.async_exec(req, resp, [&](error_code ec, std::size_t) {
+      exec_finished = true;
+      BOOST_TEST_EQ(ec, error_code());
+
+      // ROLE outputs an array, 1st element should be 'slave'
+      BOOST_TEST(resp.has_value());
+      BOOST_TEST_GE(resp.value().size(), 2u);
+      BOOST_TEST_EQ(resp.value().at(1u).value, "slave");
+
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, net::error::operation_aborted);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(exec_finished);
+   BOOST_TEST(run_finished);
+}
+
+// If no Sentinel is reachable, an error is issued.
+// This tests disabling reconnection with Sentinel, too.
+void test_error_no_sentinel_reachable()
+{
+   // Setup
+   std::string logs;
+   net::io_context ioc;
+   connection conn{ioc, make_string_logger(logs)};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "43210"},
+      {"localhost", "43211"},
+   };
+   cfg.sentinel.master_name = "mymaster";
+   cfg.reconnect_wait_interval = 0s;  // disable reconnection so we can verify the error
+
+   bool run_finished = false;
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, error::sentinel_resolve_failed);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(run_finished);
+
+   if (
+      !BOOST_TEST_NE(
+         logs.find("Sentinel at localhost:43210: connection establishment error"),
+         std::string::npos) ||
+      !BOOST_TEST_NE(
+         logs.find("Sentinel at localhost:43211: connection establishment error"),
+         std::string::npos)) {
+      std::cerr << "Log was:\n" << logs << std::endl;
+   }
+}
+
+// If Sentinel doesn't know about the configured master,
+// the appropriate error is returned
+void test_error_unknown_master()
+{
+   // Setup
+   std::string logs;
+   net::io_context ioc;
+   connection conn{ioc, make_string_logger(logs)};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26380"},
+   };
+   cfg.sentinel.master_name = "unknown_master";
+   cfg.reconnect_wait_interval = 0s;  // disable reconnection so we can verify the error
+
+   bool run_finished = false;
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, error::sentinel_resolve_failed);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(run_finished);
+
+   if (!BOOST_TEST_NE(
+          logs.find("Sentinel at localhost:26380: doesn't know about the configured master"),
+          std::string::npos)) {
+      std::cerr << "Log was:\n" << logs << std::endl;
+   }
+}
+
+// The same applies when connecting to replicas, too
+void test_error_unknown_master_replica()
+{
+   // Setup
+   std::string logs;
+   net::io_context ioc;
+   connection conn{ioc, make_string_logger(logs)};
+
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26380"},
+   };
+   cfg.sentinel.master_name = "unknown_master";
+   cfg.reconnect_wait_interval = 0s;  // disable reconnection so we can verify the error
+   cfg.sentinel.server_role = role::replica;
+
+   bool run_finished = false;
+
+   conn.async_run(cfg, [&](error_code ec) {
+      run_finished = true;
+      BOOST_TEST_EQ(ec, error::sentinel_resolve_failed);
+   });
+
+   ioc.run_for(test_timeout);
+
+   BOOST_TEST(run_finished);
+
+   if (!BOOST_TEST_NE(
+          logs.find("Sentinel at localhost:26380: doesn't know about the configured master"),
+          std::string::npos)) {
+      std::cerr << "Log was:\n" << logs << std::endl;
+   }
+}
+
+}  // namespace
+
+int main()
+{
+   // Create the required users in the master, replicas and sentinels
+   create_user("6379", "redis_user", "redis_pass");
+   create_user("6380", "redis_user", "redis_pass");
+   create_user("6381", "redis_user", "redis_pass");
+   create_user("26379", "sentinel_user", "sentinel_pass");
+   create_user("26380", "sentinel_user", "sentinel_pass");
+   create_user("26381", "sentinel_user", "sentinel_pass");
+
+   // Actual tests
+   test_exec();
+   test_receive();
+   test_reconnect();
+   test_sentinel_not_reachable();
+   test_auth();
+   test_tls();
+   test_replica();
+
+   test_error_no_sentinel_reachable();
+   test_error_unknown_master();
+   test_error_unknown_master_replica();
+
+   return boost::report_errors();
+}

test/test_conn_setup.cpp

@@ -18,7 +18,6 @@
 #include "common.hpp"
 
 #include <iostream>
-#include <sstream>
 #include <string>
 #include <string_view>
 
@@ -29,37 +28,6 @@ using boost::system::error_code;
 
 namespace {
 
-// Creates a user with a known password. Harmless if the user already exists
-void setup_password()
-{
-   // Setup
-   asio::io_context ioc;
-   redis::connection conn{ioc};
-
-   // Enable the user and grant them permissions on everything
-   redis::request req;
-   req.push("ACL", "SETUSER", "myuser", "on", ">mypass", "~*", "&*", "+@all");
-   redis::generic_response resp;
-
-   bool run_finished = false, exec_finished = false;
-   conn.async_run(make_test_config(), [&](error_code ec) {
-      run_finished = true;
-      BOOST_TEST_EQ(ec, asio::error::operation_aborted);
-   });
-
-   conn.async_exec(req, resp, [&](error_code ec, std::size_t) {
-      exec_finished = true;
-      BOOST_TEST_EQ(ec, error_code());
-      conn.cancel();
-   });
-
-   ioc.run_for(test_timeout);
-
-   BOOST_TEST(run_finished);
-   BOOST_TEST(exec_finished);
-   BOOST_TEST(resp.has_value());
-}
-
 void test_auth_success()
 {
    // Setup
@@ -96,17 +64,13 @@ void test_auth_success()
    BOOST_TEST_EQ(std::get<0>(resp).value(), "myuser");
 }
 
+// Verify that we log appropriately (see https://github.com/boostorg/redis/issues/297)
 void test_auth_failure()
 {
-   // Verify that we log appropriately (see https://github.com/boostorg/redis/issues/297)
-   std::ostringstream oss;
-   redis::logger lgr(redis::logger::level::info, [&](redis::logger::level, std::string_view msg) {
-      oss << msg << '\n';
-   });
-
    // Setup
+   std::string logs;
    asio::io_context ioc;
-   redis::connection conn{ioc, std::move(lgr)};
+   redis::connection conn{ioc, make_string_logger(logs)};
 
    // Disable reconnection so the hello error causes the connection to exit
    auto cfg = make_test_config();
@@ -126,9 +90,8 @@ void test_auth_failure()
    BOOST_TEST(run_finished);
 
    // Check the log
-   auto log = oss.str();
-   if (!BOOST_TEST_NE(log.find("WRONGPASS"), std::string::npos)) {
-      std::cerr << "Log was: " << log << std::endl;
+   if (!BOOST_TEST_NE(logs.find("WRONGPASS"), std::string::npos)) {
+      std::cerr << "Log was: \n" << logs << std::endl;
    }
 }
 
@@ -275,17 +238,13 @@ void test_setup_no_hello()
    BOOST_TEST_EQ(find_client_info(std::get<0>(resp).value(), "db"), "8");
 }
 
+// Verify that we log appropriately (see https://github.com/boostorg/redis/issues/297)
 void test_setup_failure()
 {
-   // Verify that we log appropriately (see https://github.com/boostorg/redis/issues/297)
-   std::ostringstream oss;
-   redis::logger lgr(redis::logger::level::info, [&](redis::logger::level, std::string_view msg) {
-      oss << msg << '\n';
-   });
-
    // Setup
+   std::string logs;
    asio::io_context ioc;
-   redis::connection conn{ioc, std::move(lgr)};
+   redis::connection conn{ioc, make_string_logger(logs)};
 
    // Disable reconnection so the hello error causes the connection to exit
    auto cfg = make_test_config();
@@ -306,9 +265,8 @@ void test_setup_failure()
    BOOST_TEST(run_finished);
 
    // Check the log
-   auto log = oss.str();
-   if (!BOOST_TEST_NE(log.find("wrong number of arguments"), std::string::npos)) {
-      std::cerr << "Log was: " << log << std::endl;
+   if (!BOOST_TEST_NE(logs.find("wrong number of arguments"), std::string::npos)) {
+      std::cerr << "Log was:\n" << logs << std::endl;
    }
 }
 
@@ -316,7 +274,8 @@ void test_setup_failure()
 
 int main()
 {
-   setup_password();
+   create_user("6379", "myuser", "mypass");
+
    test_auth_success();
    test_auth_failure();
    test_database_index();

test/test_conn_tls.cpp

@@ -55,7 +55,7 @@ static config make_tls_config()
    config cfg;
    cfg.use_ssl = true;
    cfg.addr.host = get_server_hostname();
-   cfg.addr.port = "6380";
+   cfg.addr.port = "16380";
    return cfg;
 }
 

test/test_connect_fsm.cpp

@@ -6,7 +6,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/redis/config.hpp>
 #include <boost/redis/detail/connect_fsm.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/redis/logger.hpp>
@@ -103,30 +102,15 @@ auto resolver_data = [] {
 
 // Reduce duplication
 struct fixture : detail::log_fixture {
-   config cfg;
    buffered_logger lgr{make_logger()};
-   connect_fsm fsm{cfg, lgr};
-   redis_stream_state st{};
+   connect_fsm fsm{lgr};
+   redis_stream_state st;
 
-   fixture(config&& cfg = {})
-   : cfg{std::move(cfg)}
+   fixture(transport_type type = transport_type::tcp)
+   : st{type, false}
    { }
 };
 
-config make_ssl_config()
-{
-   config cfg;
-   cfg.use_ssl = true;
-   return cfg;
-}
-
-config make_unix_config()
-{
-   config cfg;
-   cfg.unix_socket = "/run/redis.sock";
-   return cfg;
-}
-
 void test_tcp_success()
 {
    // Setup
@@ -141,20 +125,21 @@ void test_tcp_success()
    BOOST_TEST_EQ(act, connect_action_type::done);
 
    // The transport type was appropriately set
-   BOOST_TEST_EQ(fix.st.type, transport_type::tcp);
    BOOST_TEST_NOT(fix.st.ssl_stream_used);
 
    // Check logging
    fix.check_log({
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Connected to 192.168.10.1:1234"                       },
+      // clang-format off
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::debug, "Connect: TCP connect succeeded. Selected endpoint: 192.168.10.1:1234"      },
+      // clang-format on
    });
 }
 
 void test_tcp_tls_success()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
 
    // Run the algorithm. No SSL stream reset is performed here
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -167,21 +152,22 @@ void test_tcp_tls_success()
    BOOST_TEST_EQ(act, connect_action_type::done);
 
    // The transport type was appropriately set
-   BOOST_TEST_EQ(fix.st.type, transport_type::tcp_tls);
    BOOST_TEST(fix.st.ssl_stream_used);
 
    // Check logging
    fix.check_log({
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Connected to 192.168.10.1:1234"                       },
-      {logger::level::info, "Successfully performed SSL handshake"                 },
+      // clang-format off
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::debug, "Connect: TCP connect succeeded. Selected endpoint: 192.168.10.1:1234"      },
+      {logger::level::debug, "Connect: SSL handshake succeeded"                                          },
+      // clang-format on
    });
 }
 
 void test_tcp_tls_success_reconnect()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
    fix.st.ssl_stream_used = true;
 
    // Run the algorithm. The stream is used, so it needs to be reset
@@ -197,21 +183,22 @@ void test_tcp_tls_success_reconnect()
    BOOST_TEST_EQ(act, connect_action_type::done);
 
    // The transport type was appropriately set
-   BOOST_TEST_EQ(fix.st.type, transport_type::tcp_tls);
    BOOST_TEST(fix.st.ssl_stream_used);
 
    // Check logging
    fix.check_log({
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Connected to 192.168.10.1:1234"                       },
-      {logger::level::info, "Successfully performed SSL handshake"                 },
+      // clang-format off
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::debug, "Connect: TCP connect succeeded. Selected endpoint: 192.168.10.1:1234"      },
+      {logger::level::debug, "Connect: SSL handshake succeeded"                    },
+      // clang-format on
    });
 }
 
 void test_unix_success()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -222,12 +209,11 @@ void test_unix_success()
    BOOST_TEST_EQ(act, connect_action_type::done);
 
    // The transport type was appropriately set
-   BOOST_TEST_EQ(fix.st.type, transport_type::unix_socket);
    BOOST_TEST_NOT(fix.st.ssl_stream_used);
 
    // Check logging
    fix.check_log({
-      {logger::level::info, "Connected to /run/redis.sock"},
+      {logger::level::debug, "Connect: UNIX socket connect succeeded"},
    });
 }
 
@@ -235,7 +221,7 @@ void test_unix_success()
 void test_unix_success_close_error()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -246,12 +232,11 @@ void test_unix_success_close_error()
    BOOST_TEST_EQ(act, connect_action_type::done);
 
    // The transport type was appropriately set
-   BOOST_TEST_EQ(fix.st.type, transport_type::unix_socket);
    BOOST_TEST_NOT(fix.st.ssl_stream_used);
 
    // Check logging
    fix.check_log({
-      {logger::level::info, "Connected to /run/redis.sock"},
+      {logger::level::debug, "Connect: UNIX socket connect succeeded"},
    });
 }
 
@@ -270,7 +255,7 @@ void test_tcp_resolve_error()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Error resolving the server hostname: Expected field value is empty. [boost.redis:5]"},
+      {logger::level::info, "Connect: hostname resolution failed: Expected field value is empty. [boost.redis:5]"},
       // clang-format on
    });
 }
@@ -293,7 +278,7 @@ void test_tcp_resolve_timeout()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Error resolving the server hostname: Resolve timeout. [boost.redis:17]"},
+      {logger::level::info, "Connect: hostname resolution failed: Resolve timeout. [boost.redis:17]"},
       // clang-format on
    });
 }
@@ -349,8 +334,8 @@ void test_tcp_connect_error()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Failed to connect to the server: Expected field value is empty. [boost.redis:5]"},
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::info, "Connect: TCP connect failed: Expected field value is empty. [boost.redis:5]"},
       // clang-format on
    });
 }
@@ -375,8 +360,8 @@ void test_tcp_connect_timeout()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Failed to connect to the server: Connect timeout. [boost.redis:18]"},
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::info, "Connect: TCP connect failed: Connect timeout. [boost.redis:18]"},
       // clang-format on
    });
 }
@@ -423,7 +408,7 @@ void test_tcp_connect_cancel_edge()
 void test_ssl_handshake_error()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
 
    // Run the algorithm. No SSL stream reset is performed here
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -441,9 +426,9 @@ void test_ssl_handshake_error()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Connected to 192.168.10.1:1234"                       },
-      {logger::level::info, "Failed to perform SSL handshake: Expected field value is empty. [boost.redis:5]"},
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::debug, "Connect: TCP connect succeeded. Selected endpoint: 192.168.10.1:1234"},
+      {logger::level::info,  "Connect: SSL handshake failed: Expected field value is empty. [boost.redis:5]"},
       // clang-format on
    });
 }
@@ -451,7 +436,7 @@ void test_ssl_handshake_error()
 void test_ssl_handshake_timeout()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
 
    // Run the algorithm. Timeout = operation_aborted without the cancel type set
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -469,9 +454,9 @@ void test_ssl_handshake_timeout()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Resolve results: 192.168.10.1:1234, 192.168.10.2:1235"},
-      {logger::level::info, "Connected to 192.168.10.1:1234"                       },
-      {logger::level::info, "Failed to perform SSL handshake: SSL handshake timeout. [boost.redis:20]"},
+      {logger::level::debug, "Connect: hostname resolution results: 192.168.10.1:1234, 192.168.10.2:1235"},
+      {logger::level::debug, "Connect: TCP connect succeeded. Selected endpoint: 192.168.10.1:1234"},
+      {logger::level::info,  "Connect: SSL handshake failed: SSL handshake timeout. [boost.redis:20]"},
       // clang-format on
    });
 }
@@ -479,7 +464,7 @@ void test_ssl_handshake_timeout()
 void test_ssl_handshake_cancel()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
 
    // Run the algorithm. Cancel = operation_aborted with the cancel type set
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -501,7 +486,7 @@ void test_ssl_handshake_cancel()
 void test_ssl_handshake_cancel_edge()
 {
    // Setup
-   fixture fix{make_ssl_config()};
+   fixture fix{transport_type::tcp_tls};
 
    // Run the algorithm. No error, but the cancel state is set
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -524,7 +509,7 @@ void test_ssl_handshake_cancel_edge()
 void test_unix_connect_error()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -537,7 +522,7 @@ void test_unix_connect_error()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Failed to connect to the server: Expected field value is empty. [boost.redis:5]"},
+      {logger::level::info, "Connect: UNIX socket connect failed: Expected field value is empty. [boost.redis:5]"},
       // clang-format on
    });
 }
@@ -545,7 +530,7 @@ void test_unix_connect_error()
 void test_unix_connect_timeout()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm. Timeout = operation_aborted without a cancel state
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -558,7 +543,7 @@ void test_unix_connect_timeout()
    // Check logging
    fix.check_log({
       // clang-format off
-      {logger::level::info, "Failed to connect to the server: Connect timeout. [boost.redis:18]"},
+      {logger::level::info, "Connect: UNIX socket connect failed: Connect timeout. [boost.redis:18]"},
       // clang-format on
    });
 }
@@ -566,7 +551,7 @@ void test_unix_connect_timeout()
 void test_unix_connect_cancel()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm. Cancel = operation_aborted with a cancel state
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);
@@ -583,7 +568,7 @@ void test_unix_connect_cancel()
 void test_unix_connect_cancel_edge()
 {
    // Setup
-   fixture fix{make_unix_config()};
+   fixture fix{transport_type::unix_socket};
 
    // Run the algorithm. No error, but cancel state is set
    auto act = fix.fsm.resume(error_code(), fix.st, cancellation_type_t::none);

test/test_exec_one_fsm.cpp

@@ -0,0 +1,365 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/detail/exec_one_fsm.hpp>
+#include <boost/redis/detail/read_buffer.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/type.hpp>
+
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/error_code.hpp>
+
+#include "print_node.hpp"
+
+#include <iterator>
+#include <ostream>
+#include <string_view>
+#include <vector>
+
+using namespace boost::redis;
+namespace asio = boost::asio;
+using detail::exec_one_fsm;
+using detail::exec_one_action;
+using detail::exec_one_action_type;
+using detail::read_buffer;
+using boost::system::error_code;
+using boost::asio::cancellation_type_t;
+using parse_event = any_adapter::parse_event;
+using resp3::type;
+
+// Operators
+static const char* to_string(exec_one_action_type value)
+{
+   switch (value) {
+      case exec_one_action_type::done:      return "done";
+      case exec_one_action_type::write:     return "write";
+      case exec_one_action_type::read_some: return "read_some";
+      default:                              return "<unknown writer_action_type>";
+   }
+}
+
+namespace boost::redis::detail {
+
+bool operator==(const exec_one_action& lhs, const exec_one_action& rhs) noexcept
+{
+   return lhs.type == rhs.type && lhs.ec == rhs.ec;
+}
+
+std::ostream& operator<<(std::ostream& os, const exec_one_action& act)
+{
+   os << "exec_one_action{ .type=" << to_string(act.type);
+   if (act.type == exec_one_action_type::done)
+      os << ", ec=" << act.ec;
+   return os << " }";
+}
+
+}  // namespace boost::redis::detail
+
+namespace {
+
+struct adapter_event {
+   parse_event type;
+   resp3::node node{};
+
+   friend bool operator==(const adapter_event& lhs, const adapter_event& rhs) noexcept
+   {
+      return lhs.type == rhs.type && lhs.node == rhs.node;
+   }
+
+   friend std::ostream& operator<<(std::ostream& os, const adapter_event& value)
+   {
+      switch (value.type) {
+         case parse_event::init: return os << "adapter_event{ .type=init }";
+         case parse_event::done: return os << "adapter_event{ .type=done }";
+         case parse_event::node:
+            return os << "adapter_event{ .type=node, .node=" << value.node << " }";
+         default: return os << "adapter_event{ .type=unknown }";
+      }
+   }
+};
+
+any_adapter make_snoop_adapter(std::vector<adapter_event>& events)
+{
+   return any_adapter::impl_t{[&](parse_event ev, resp3::node_view const& nd, error_code&) {
+      events.push_back({
+         ev,
+         {nd.data_type, nd.aggregate_size, nd.depth, std::string(nd.value)}
+      });
+   }};
+}
+
+void copy_to(read_buffer& buff, std::string_view data)
+{
+   auto const buffer = buff.get_prepared();
+   BOOST_TEST_GE(buffer.size(), data.size());
+   std::copy(data.cbegin(), data.cend(), buffer.begin());
+}
+
+void test_success()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // Read the entire response in one go
+   constexpr std::string_view payload = "$5\r\nhello\r\n*1\r\n+goodbye\r\n";
+   copy_to(buff, payload);
+   act = fsm.resume(buff, error_code(), payload.size(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::done);
+
+   // Verify the adapter calls
+   const adapter_event expected[] = {
+      {parse_event::init},
+      {parse_event::node, {type::blob_string, 1u, 0u, "hello"}},
+      {parse_event::done},
+      {parse_event::init},
+      {parse_event::node, {type::array, 1u, 0u, ""}},
+      {parse_event::node, {type::simple_string, 1u, 1u, "goodbye"}},
+      {parse_event::done},
+   };
+   BOOST_TEST_ALL_EQ(events.begin(), events.end(), std::begin(expected), std::end(expected));
+}
+
+// The request didn't have any expected response (e.g. SUBSCRIBE)
+void test_no_expected_response()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 0u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM shouldn't ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // No adapter calls should be done
+   BOOST_TEST_EQ(events.size(), 0u);
+}
+
+// The response is scattered in several smaller fragments
+void test_short_reads()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // Read fragments
+   constexpr std::string_view payload = "$5\r\nhello\r\n*1\r\n+goodbye\r\n";
+   copy_to(buff, payload.substr(0, 6u));
+   act = fsm.resume(buff, error_code(), 6u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   copy_to(buff, payload.substr(6, 10u));
+   act = fsm.resume(buff, error_code(), 10u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   copy_to(buff, payload.substr(16));
+   act = fsm.resume(buff, error_code(), payload.substr(16).size(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::done);
+
+   // Verify the adapter calls
+   const adapter_event expected[] = {
+      {parse_event::init},
+      {parse_event::node, {type::blob_string, 1u, 0u, "hello"}},
+      {parse_event::done},
+      {parse_event::init},
+      {parse_event::node, {type::array, 1u, 0u, ""}},
+      {parse_event::node, {type::simple_string, 1u, 1u, "goodbye"}},
+      {parse_event::done},
+   };
+   BOOST_TEST_ALL_EQ(events.begin(), events.end(), std::begin(expected), std::end(expected));
+}
+
+// Errors in write
+void test_write_error()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // Write error
+   act = fsm.resume(buff, asio::error::connection_reset, 10u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(asio::error::connection_reset));
+}
+
+void test_write_cancel()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // Edge case where the operation finished successfully but with the cancellation state set
+   act = fsm.resume(buff, error_code(), 10u, cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+}
+
+// Errors in read
+void test_read_error()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // Read error
+   act = fsm.resume(buff, asio::error::network_reset, 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(asio::error::network_reset));
+}
+
+void test_read_cancelled()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // Edge case where the operation finished successfully but with the cancellation state set
+   copy_to(buff, "$5\r\n");
+   act = fsm.resume(buff, error_code(), 4u, cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+}
+
+// Buffer too small
+void test_buffer_prepare_error()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+   buff.set_config({4096u, 8u});  // max size is 8 bytes
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // When preparing the buffer, we encounter an error
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::exceeds_maximum_read_buffer_size));
+}
+
+// An invalid RESP3 message
+void test_parse_error()
+{
+   // Setup
+   std::vector<adapter_event> events;
+   exec_one_fsm fsm{make_snoop_adapter(events), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // The response contains an invalid message
+   constexpr std::string_view payload = "$bad\r\n";
+   copy_to(buff, payload);
+   act = fsm.resume(buff, error_code(), payload.size(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::not_a_number));
+}
+
+// Adapter signals an error
+void test_adapter_error()
+{
+   // Setup. The adapter will fail in the 2nd node
+   any_adapter adapter{[](parse_event ev, resp3::node_view const&, error_code& ec) {
+      if (ev == parse_event::node)
+         ec = error::empty_field;
+   }};
+   exec_one_fsm fsm{std::move(adapter), 2u};
+   read_buffer buff;
+
+   // Write the request
+   auto act = fsm.resume(buff, error_code(), 0u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::write);
+
+   // FSM should now ask for data
+   act = fsm.resume(buff, error_code(), 25u, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, exec_one_action_type::read_some);
+
+   // Read the entire response in one go
+   constexpr std::string_view payload = "$5\r\nhello\r\n*1\r\n+goodbye\r\n";
+   copy_to(buff, payload);
+   act = fsm.resume(buff, error_code(), payload.size(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::empty_field));
+}
+
+}  // namespace
+
+int main()
+{
+   test_success();
+   test_no_expected_response();
+   test_short_reads();
+
+   test_write_error();
+   test_write_cancel();
+
+   test_read_error();
+   test_read_cancelled();
+
+   test_buffer_prepare_error();
+   test_parse_error();
+   test_adapter_error();
+
+   return boost::report_errors();
+}

test/test_flat_tree.cpp

@@ -0,0 +1,881 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/adapter/adapt.hpp>
+#include <boost/redis/resp3/flat_tree.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/type.hpp>
+
+#include <boost/assert/source_location.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/span.hpp>
+
+#include "print_node.hpp"
+
+#include <algorithm>
+#include <initializer_list>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+using boost::redis::adapter::adapt2;
+using boost::redis::adapter::result;
+using boost::redis::resp3::tree;
+using boost::redis::resp3::flat_tree;
+using boost::redis::generic_flat_response;
+using boost::redis::resp3::type;
+using boost::redis::resp3::detail::deserialize;
+using boost::redis::resp3::node;
+using boost::redis::resp3::node_view;
+using boost::redis::resp3::to_string;
+using boost::redis::response;
+using boost::system::error_code;
+
+namespace {
+
+void add_nodes(
+   flat_tree& to,
+   std::string_view data,
+   boost::source_location loc = BOOST_CURRENT_LOCATION)
+{
+   error_code ec;
+   deserialize(data, adapt2(to), ec);
+   if (!BOOST_TEST_EQ(ec, error_code{}))
+      std::cerr << "Called from " << loc << std::endl;
+}
+
+void check_nodes(
+   const flat_tree& tree,
+   boost::span<const node_view> expected,
+   boost::source_location loc = BOOST_CURRENT_LOCATION)
+{
+   if (!BOOST_TEST_ALL_EQ(
+          tree.get_view().begin(),
+          tree.get_view().end(),
+          expected.begin(),
+          expected.end()))
+      std::cerr << "Called from " << loc << std::endl;
+}
+
+// --- Adding nodes ---
+// Adding nodes works, even when reallocations happen.
+// Empty nodes don't cause trouble
+void test_add_nodes()
+{
+   flat_tree t;
+
+   // Add a bunch of nodes. Single allocation. Some nodes are empty.
+   add_nodes(t, "*2\r\n+hello\r\n+world\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 10u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+
+   // Capacity will have raised to 512 bytes, at least. Add some more without reallocations
+   add_nodes(t, "$3\r\nbye\r\n");
+   expected_nodes.push_back({type::blob_string, 1u, 0u, "bye"});
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 13u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 2u);
+
+   // Add nodes above the first reallocation threshold. Node strings are still valid
+   const std::string long_value(600u, 'a');
+   add_nodes(t, "+" + long_value + "\r\n");
+   expected_nodes.push_back({type::simple_string, 1u, 0u, long_value});
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 613u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024u);
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 3u);
+
+   // Add some more nodes, still within the reallocation threshold
+   add_nodes(t, "+some_other_value\r\n");
+   expected_nodes.push_back({type::simple_string, 1u, 0u, "some_other_value"});
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 629u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024u);
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 4u);
+
+   // Add some more, causing another reallocation
+   add_nodes(t, "+" + long_value + "\r\n");
+   expected_nodes.push_back({type::simple_string, 1u, 0u, long_value});
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 1229u);
+   BOOST_TEST_EQ(t.data_capacity(), 2048u);
+   BOOST_TEST_EQ(t.get_reallocs(), 3u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 5u);
+}
+
+// Strings are really copied into the object
+void test_add_nodes_copies()
+{
+   flat_tree t;
+
+   // Place the message in dynamic memory
+   constexpr std::string_view const_msg = "+some_long_value_for_a_node\r\n";
+   std::unique_ptr<char[]> data{new char[100]{}};
+   std::copy(const_msg.begin(), const_msg.end(), data.get());
+
+   // Add nodes pointing into this message
+   add_nodes(t, data.get());
+
+   // Invalidate the original message
+   data.reset();
+
+   // Check
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "some_long_value_for_a_node"},
+   };
+   check_nodes(t, expected_nodes);
+}
+
+// Reallocations happen only when we would exceed capacity
+void test_add_nodes_capacity_limit()
+{
+   flat_tree t;
+
+   // Add a node to reach capacity 512
+   add_nodes(t, "+hello\r\n");
+   BOOST_TEST_EQ(t.data_size(), 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+
+   // Fill the rest of the capacity
+   add_nodes(t, "+" + std::string(507u, 'b') + "\r\n");
+   BOOST_TEST_EQ(t.data_size(), 512u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+
+   // Adding an empty node here doesn't change capacity
+   add_nodes(t, "_\r\n");
+   BOOST_TEST_EQ(t.data_size(), 512u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+
+   // Adding more data causes a reallocation
+   add_nodes(t, "+a\r\n");
+   BOOST_TEST_EQ(t.data_size(), 513u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024);
+
+   // Same goes for the next capacity limit
+   add_nodes(t, "+" + std::string(511u, 'c') + "\r\n");
+   BOOST_TEST_EQ(t.data_size(), 1024);
+   BOOST_TEST_EQ(t.data_capacity(), 1024);
+
+   // Reallocation
+   add_nodes(t, "+u\r\n");
+   BOOST_TEST_EQ(t.data_size(), 1025u);
+   BOOST_TEST_EQ(t.data_capacity(), 2048u);
+
+   // This would continue
+   add_nodes(t, "+" + std::string(1024u, 'd') + "\r\n");
+   BOOST_TEST_EQ(t.data_size(), 2049u);
+   BOOST_TEST_EQ(t.data_capacity(), 4096u);
+}
+
+// It's no problem if a node is big enough to surpass several reallocation limits
+void test_add_nodes_big_node()
+{
+   flat_tree t;
+
+   // Add a bunch of nodes. Single allocation. Some nodes are empty.
+   const std::string long_value(1500u, 'h');
+   add_nodes(t, "+" + long_value + "\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, long_value},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 1500u);
+   BOOST_TEST_EQ(t.data_capacity(), 2048u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// --- Reserving space ---
+// The usual case, calling it before using it
+void test_reserve()
+{
+   flat_tree t;
+
+   t.reserve(1024u, 5u);
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.get_view().capacity(), 5u);
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+
+   // Adding some nodes now works
+   add_nodes(t, "+hello\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+   check_nodes(t, expected_nodes);
+}
+
+// Reserving space uses the same allocation thresholds
+void test_reserve_not_power_of_2()
+{
+   flat_tree t;
+
+   // First threshold at 512
+   t.reserve(200u, 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+
+   // Second threshold at 1024
+   t.reserve(600u, 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024u);
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);
+}
+
+// Requesting a capacity below the current one does nothing
+void test_reserve_below_current_capacity()
+{
+   flat_tree t;
+
+   // Reserving with a zero capacity does nothing
+   t.reserve(0u, 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+
+   // Increase capacity
+   t.reserve(400u, 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+
+   // Reserving again does nothing
+   t.reserve(400u, 5u);
+   t.reserve(512u, 5u);
+   t.reserve(0u, 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+}
+
+// Reserving might reallocate. If there are nodes, strings remain valid
+void test_reserve_with_data()
+{
+   flat_tree t;
+
+   // Add a bunch of nodes, and then reserve
+   add_nodes(t, "*2\r\n+hello\r\n+world\r\n");
+   t.reserve(1000u, 10u);
+
+   // Check
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 10u);
+   BOOST_TEST_EQ(t.data_capacity(), 1024u);
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// --- Clear ---
+void test_clear()
+{
+   flat_tree t;
+
+   // Add a bunch of nodes, then clear
+   add_nodes(t, "*2\r\n+hello\r\n+world\r\n");
+   t.clear();
+
+   // Nodes are no longer there, but memory hasn't been fred
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// Clearing an empty tree doesn't cause trouble
+void test_clear_empty()
+{
+   flat_tree t;
+   t.clear();
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// With clear, memory can be reused
+// The response should be reusable.
+void test_clear_reuse()
+{
+   flat_tree t;
+
+   // First use
+   add_nodes(t, "~6\r\n+orange\r\n+apple\r\n+one\r\n+two\r\n+three\r\n+orange\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::set,           6u, 0u, ""      },
+      {type::simple_string, 1u, 1u, "orange"},
+      {type::simple_string, 1u, 1u, "apple" },
+      {type::simple_string, 1u, 1u, "one"   },
+      {type::simple_string, 1u, 1u, "two"   },
+      {type::simple_string, 1u, 1u, "three" },
+      {type::simple_string, 1u, 1u, "orange"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+
+   // Second use
+   t.clear();
+   add_nodes(t, "*2\r\n+hello\r\n+world\r\n");
+   expected_nodes = {
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// --- Default ctor ---
+void test_default_constructor()
+{
+   flat_tree t;
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// --- Copy ctor ---
+void test_copy_ctor()
+{
+   // Setup
+   auto t = std::make_unique<flat_tree>();
+   add_nodes(*t, "*2\r\n+hello\r\n+world\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+
+   // Construct, then destroy the original copy
+   flat_tree t2{*t};
+   t.reset();
+
+   // Check
+   check_nodes(t2, expected_nodes);
+   BOOST_TEST_EQ(t2.data_size(), 10u);
+   BOOST_TEST_EQ(t2.data_capacity(), 512u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 1u);
+}
+
+// Copying an empty tree doesn't cause problems
+void test_copy_ctor_empty()
+{
+   flat_tree t;
+   flat_tree t2{t};
+   check_nodes(t2, {});
+   BOOST_TEST_EQ(t2.data_size(), 0u);
+   BOOST_TEST_EQ(t2.data_capacity(), 0u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 0u);
+}
+
+// Copying an object that has no elements but some capacity doesn't cause trouble
+void test_copy_ctor_empty_with_capacity()
+{
+   flat_tree t;
+   t.reserve(300u, 8u);
+
+   flat_tree t2{t};
+   check_nodes(t2, {});
+   BOOST_TEST_EQ(t2.data_size(), 0u);
+   BOOST_TEST_EQ(t2.data_capacity(), 0u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 0u);
+}
+
+// Copying an object with more capacity than required adjusts its capacity
+void test_copy_ctor_adjust_capacity()
+{
+   // Setup
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+
+   // Cause reallocations
+   t.reserve(1000u, 10u);
+   t.reserve(2000u, 10u);
+   t.reserve(4000u, 10u);
+
+   // Copy
+   flat_tree t2{t};
+
+   // The target object has the minimum required capacity,
+   // and the number of reallocs has been reset
+   check_nodes(t2, expected_nodes);
+   BOOST_TEST_EQ(t2.data_size(), 5u);
+   BOOST_TEST_EQ(t2.data_capacity(), 512u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 1u);
+}
+
+// --- Move ctor ---
+void test_move_ctor()
+{
+   flat_tree t;
+   add_nodes(t, "*2\r\n+hello\r\n+world\r\n");
+
+   flat_tree t2{std::move(t)};
+
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t2, expected_nodes);
+   BOOST_TEST_EQ(t2.data_size(), 10u);
+   BOOST_TEST_EQ(t2.data_capacity(), 512u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 1u);
+}
+
+// Moving an empty object doesn't cause trouble
+void test_move_ctor_empty()
+{
+   flat_tree t;
+
+   flat_tree t2{std::move(t)};
+
+   check_nodes(t2, {});
+   BOOST_TEST_EQ(t2.data_size(), 0u);
+   BOOST_TEST_EQ(t2.data_capacity(), 0u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 0u);
+}
+
+// Moving an object with capacity but no data doesn't cause trouble
+void test_move_ctor_with_capacity()
+{
+   flat_tree t;
+   t.reserve(1000u, 10u);
+
+   flat_tree t2{std::move(t)};
+
+   check_nodes(t2, {});
+   BOOST_TEST_EQ(t2.data_size(), 0u);
+   BOOST_TEST_EQ(t2.data_capacity(), 1024u);
+   BOOST_TEST_EQ(t2.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t2.get_total_msgs(), 0u);
+}
+
+// --- Copy assignment ---
+void test_copy_assign()
+{
+   flat_tree t;
+   add_nodes(t, "+some_data\r\n");
+
+   auto t2 = std::make_unique<flat_tree>();
+   add_nodes(*t2, "*2\r\n+hello\r\n+world\r\n");
+
+   t = *t2;
+
+   // Delete the source object, to check that we copied the contents
+   t2.reset();
+
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 10u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// The lhs is empty and doesn't have any capacity
+void test_copy_assign_target_empty()
+{
+   flat_tree t;
+
+   flat_tree t2;
+   add_nodes(t2, "+hello\r\n");
+
+   t = t2;
+
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// If the target doesn't have enough capacity, a reallocation happens
+void test_copy_assign_target_not_enough_capacity()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   const std::string big_node(2000u, 'a');
+   flat_tree t2;
+   add_nodes(t2, "+" + big_node + "\r\n");
+
+   t = t2;
+
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, big_node},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 2000u);
+   BOOST_TEST_EQ(t.data_capacity(), 2048u);
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);  // initial + assignment
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// If the source of the assignment is empty, nothing bad happens
+void test_copy_assign_source_empty()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   flat_tree t2;
+
+   t = t2;
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);  // capacity is kept
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// If the source of the assignment has capacity but no data, we're OK
+void test_copy_assign_source_with_capacity()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   flat_tree t2;
+   t2.reserve(1000u, 4u);
+   t2.reserve(4000u, 8u);
+
+   t = t2;
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);  // capacity is kept
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);     // not propagated
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// If the source of the assignment has data with extra capacity
+// and a reallocation is needed, the minimum amount of space is allocated
+void test_copy_assign_source_with_extra_capacity()
+{
+   flat_tree t;
+
+   flat_tree t2;
+   add_nodes(t2, "+hello\r\n");
+   t2.reserve(4000u, 8u);
+
+   t = t2;
+
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+void test_copy_assign_both_empty()
+{
+   flat_tree t;
+   flat_tree t2;
+
+   t = t2;
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// Self-assignment doesn't cause trouble
+void test_copy_assign_self()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   const auto& tref = t;
+   t = tref;
+
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// --- Move assignment ---
+void test_move_assign()
+{
+   flat_tree t;
+   add_nodes(t, "+some_data\r\n");
+
+   flat_tree t2;
+   add_nodes(t2, "*2\r\n+hello\r\n+world\r\n");
+
+   t = std::move(t2);
+
+   std::vector<node_view> expected_nodes{
+      {type::array,         2u, 0u, ""     },
+      {type::simple_string, 1u, 1u, "hello"},
+      {type::simple_string, 1u, 1u, "world"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 10u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// The lhs is empty and doesn't have any capacity
+void test_move_assign_target_empty()
+{
+   flat_tree t;
+
+   flat_tree t2;
+   add_nodes(t2, "+hello\r\n");
+
+   t = std::move(t2);
+
+   std::vector<node_view> expected_nodes{
+      {type::simple_string, 1u, 0u, "hello"},
+   };
+   check_nodes(t, expected_nodes);
+   BOOST_TEST_EQ(t.data_size(), 5u);
+   BOOST_TEST_EQ(t.data_capacity(), 512u);
+   BOOST_TEST_EQ(t.get_reallocs(), 1u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 1u);
+}
+
+// If the source of the assignment is empty, nothing bad happens
+void test_move_assign_source_empty()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   flat_tree t2;
+
+   t = std::move(t2);
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// If both source and target are empty, nothing bad happens
+void test_move_assign_both_empty()
+{
+   flat_tree t;
+
+   flat_tree t2;
+
+   t = std::move(t2);
+
+   check_nodes(t, {});
+   BOOST_TEST_EQ(t.data_size(), 0u);
+   BOOST_TEST_EQ(t.data_capacity(), 0u);
+   BOOST_TEST_EQ(t.get_reallocs(), 0u);
+   BOOST_TEST_EQ(t.get_total_msgs(), 0u);
+}
+
+// --- Comparison ---
+void test_comparison_different()
+{
+   flat_tree t;
+   add_nodes(t, "+some_data\r\n");
+
+   flat_tree t2;
+   add_nodes(t2, "*2\r\n+hello\r\n+world\r\n");
+
+   BOOST_TEST_NOT(t == t2);
+   BOOST_TEST(t != t2);
+   BOOST_TEST_NOT(t2 == t);
+   BOOST_TEST(t2 != t);
+}
+
+// The only difference is node types
+void test_comparison_different_node_types()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   flat_tree t2;
+   add_nodes(t2, "$5\r\nhello\r\n");
+
+   BOOST_TEST_NOT(t == t2);
+   BOOST_TEST(t != t2);
+}
+
+void test_comparison_equal()
+{
+   flat_tree t;
+   add_nodes(t, "+some_data\r\n");
+
+   flat_tree t2;
+   add_nodes(t2, "+some_data\r\n");
+
+   BOOST_TEST(t == t2);
+   BOOST_TEST_NOT(t != t2);
+}
+
+// Allocations are not taken into account when comparing
+void test_comparison_equal_reallocations()
+{
+   const std::string big_node(2000u, 'a');
+   flat_tree t;
+   t.reserve(100u, 5u);
+   add_nodes(t, "+" + big_node + "\r\n");
+   BOOST_TEST_EQ(t.get_reallocs(), 2u);
+
+   flat_tree t2;
+   t2.reserve(2048u, 5u);
+   add_nodes(t2, "+" + big_node + "\r\n");
+   BOOST_TEST_EQ(t2.get_reallocs(), 1u);
+
+   BOOST_TEST(t == t2);
+   BOOST_TEST_NOT(t != t2);
+}
+
+// Capacity is not taken into account when comparing
+void test_comparison_equal_capacity()
+{
+   flat_tree t;
+   add_nodes(t, "+hello\r\n");
+
+   flat_tree t2;
+   t2.reserve(2048u, 5u);
+   add_nodes(t2, "+hello\r\n");
+
+   BOOST_TEST(t == t2);
+   BOOST_TEST_NOT(t != t2);
+}
+
+// Empty containers don't cause trouble
+void test_comparison_empty()
+{
+   flat_tree t;
+   add_nodes(t, "$5\r\nhello\r\n");
+
+   flat_tree tempty, tempty2;
+
+   BOOST_TEST_NOT(t == tempty);
+   BOOST_TEST(t != tempty);
+
+   BOOST_TEST_NOT(tempty == t);
+   BOOST_TEST(tempty != t);
+
+   BOOST_TEST(tempty == tempty2);
+   BOOST_TEST_NOT(tempty != tempty2);
+}
+
+// Self comparisons don't cause trouble
+void test_comparison_self()
+{
+   flat_tree t;
+   add_nodes(t, "$5\r\nhello\r\n");
+
+   flat_tree tempty;
+
+   BOOST_TEST(t == t);
+   BOOST_TEST_NOT(t != t);
+
+   BOOST_TEST(tempty == tempty);
+   BOOST_TEST_NOT(tempty != tempty);
+}
+
+}  // namespace
+
+int main()
+{
+   test_add_nodes();
+   test_add_nodes_copies();
+   test_add_nodes_capacity_limit();
+   test_add_nodes_big_node();
+
+   test_reserve();
+   test_reserve_not_power_of_2();
+   test_reserve_below_current_capacity();
+   test_reserve_with_data();
+
+   test_clear();
+   test_clear_empty();
+   test_clear_reuse();
+
+   test_default_constructor();
+
+   test_copy_ctor();
+   test_copy_ctor_empty();
+   test_copy_ctor_empty_with_capacity();
+   test_copy_ctor_adjust_capacity();
+
+   test_move_ctor();
+   test_move_ctor_empty();
+   test_move_ctor_with_capacity();
+
+   test_move_assign();
+   test_move_assign_target_empty();
+   test_move_assign_source_empty();
+   test_move_assign_both_empty();
+
+   test_copy_assign();
+   test_copy_assign_target_empty();
+   test_copy_assign_target_not_enough_capacity();
+   test_copy_assign_source_empty();
+   test_copy_assign_source_with_capacity();
+   test_copy_assign_source_with_extra_capacity();
+   test_copy_assign_both_empty();
+   test_copy_assign_self();
+
+   test_comparison_different();
+   test_comparison_different_node_types();
+   test_comparison_equal();
+   test_comparison_equal_reallocations();
+   test_comparison_equal_capacity();
+   test_comparison_empty();
+   test_comparison_self();
+
+   return boost::report_errors();
+}

test/test_issue_50.cpp

@@ -42,16 +42,15 @@ namespace {
 // Push consumer
 auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
-   std::cout << "uuu" << std::endl;
+   std::cout << "Entering receiver" << std::endl;
    while (conn->will_reconnect()) {
-      std::cout << "dddd" << std::endl;
-      // Loop reading Redis pushs messages.
-      for (;;) {
-         std::cout << "aaaa" << std::endl;
-         error_code ec;
-         co_await conn->async_receive(net::redirect_error(ec));
+      std::cout << "Reconnect loop" << std::endl;
+      // Loop reading Redis pushes.
+      for (error_code ec;;) {
+         std::cout << "Receive loop" << std::endl;
+         co_await conn->async_receive2(net::redirect_error(ec));
          if (ec) {
-            std::cout << "Error in async_receive" << std::endl;
+            std::cout << "Error in async_receive2" << std::endl;
             break;
          }
       }

test/test_low_level.cpp

@@ -530,6 +530,11 @@ BOOST_AUTO_TEST_CASE(cover_error)
    check_error("boost.redis", boost::redis::error::resp3_hello);
    check_error("boost.redis", boost::redis::error::exceeds_maximum_read_buffer_size);
    check_error("boost.redis", boost::redis::error::write_timeout);
+   check_error("boost.redis", boost::redis::error::sentinel_unix_sockets_unsupported);
+   check_error("boost.redis", boost::redis::error::sentinel_resolve_failed);
+   check_error("boost.redis", boost::redis::error::role_check_failed);
+   check_error("boost.redis", boost::redis::error::expects_resp3_string);
+   check_error("boost.redis", boost::redis::error::expects_resp3_array);
 }
 
 std::string get_type_as_str(boost::redis::resp3::type t)

test/test_low_level_sync_sans_io.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -22,15 +22,20 @@
 using boost::redis::request;
 using boost::redis::adapter::adapt2;
 using boost::redis::adapter::result;
-using boost::redis::generic_response;
+using boost::redis::resp3::tree;
+using boost::redis::resp3::flat_tree;
+using boost::redis::generic_flat_response;
 using boost::redis::ignore_t;
 using boost::redis::resp3::detail::deserialize;
 using boost::redis::resp3::node;
+using boost::redis::resp3::node_view;
 using boost::redis::resp3::to_string;
 using boost::redis::response;
 using boost::redis::any_adapter;
 using boost::system::error_code;
 
+namespace resp3 = boost::redis::resp3;
+
 #define RESP3_SET_PART1 "~6\r\n+orange\r"
 #define RESP3_SET_PART2 "\n+apple\r\n+one"
 #define RESP3_SET_PART3 "\r\n+two\r"
@@ -42,7 +47,9 @@ BOOST_AUTO_TEST_CASE(low_level_sync_sans_io)
    try {
       result<std::set<std::string>> resp;
 
-      deserialize(resp3_set, adapt2(resp));
+      error_code ec;
+      deserialize(resp3_set, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       for (auto const& e : resp.value())
          std::cout << e << std::endl;
@@ -65,7 +72,9 @@ BOOST_AUTO_TEST_CASE(issue_210_empty_set)
 
       char const* wire = "*4\r\n:1\r\n~0\r\n$25\r\nthis_should_not_be_in_set\r\n:2\r\n";
 
-      deserialize(wire, adapt2(resp));
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(std::get<0>(resp.value()).value(), 1);
       BOOST_CHECK(std::get<1>(resp.value()).value().empty());
@@ -91,7 +100,9 @@ BOOST_AUTO_TEST_CASE(issue_210_non_empty_set_size_one)
       char const*
          wire = "*4\r\n:1\r\n~1\r\n$3\r\nfoo\r\n$25\r\nthis_should_not_be_in_set\r\n:2\r\n";
 
-      deserialize(wire, adapt2(resp));
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(std::get<0>(resp.value()).value(), 1);
       BOOST_CHECK_EQUAL(std::get<1>(resp.value()).value().size(), 1u);
@@ -118,7 +129,9 @@ BOOST_AUTO_TEST_CASE(issue_210_non_empty_set_size_two)
       char const* wire =
          "*4\r\n:1\r\n~2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$25\r\nthis_should_not_be_in_set\r\n:2\r\n";
 
-      deserialize(wire, adapt2(resp));
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(std::get<0>(resp.value()).value(), 1);
       BOOST_CHECK_EQUAL(std::get<1>(resp.value()).value().at(0), std::string{"foo"});
@@ -140,7 +153,9 @@ BOOST_AUTO_TEST_CASE(issue_210_no_nested)
       char const*
          wire = "*4\r\n:1\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$25\r\nthis_should_not_be_in_set\r\n";
 
-      deserialize(wire, adapt2(resp));
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(std::get<0>(resp.value()).value(), 1);
       BOOST_CHECK_EQUAL(std::get<1>(resp.value()).value(), std::string{"foo"});
@@ -159,7 +174,10 @@ BOOST_AUTO_TEST_CASE(issue_233_array_with_null)
       result<std::vector<std::optional<std::string>>> resp;
 
       char const* wire = "*3\r\n+one\r\n_\r\n+two\r\n";
-      deserialize(wire, adapt2(resp));
+
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(resp.value().at(0).value(), "one");
       BOOST_TEST(!resp.value().at(1).has_value());
@@ -177,7 +195,10 @@ BOOST_AUTO_TEST_CASE(issue_233_optional_array_with_null)
       result<std::optional<std::vector<std::optional<std::string>>>> resp;
 
       char const* wire = "*3\r\n+one\r\n_\r\n+two\r\n";
-      deserialize(wire, adapt2(resp));
+
+      error_code ec;
+      deserialize(wire, adapt2(resp), ec);
+      BOOST_CHECK_EQUAL(ec, error_code{});
 
       BOOST_CHECK_EQUAL(resp.value().value().at(0).value(), "one");
       BOOST_TEST(!resp.value().value().at(1).has_value());
@@ -189,87 +210,6 @@ BOOST_AUTO_TEST_CASE(issue_233_optional_array_with_null)
    }
 }
 
-BOOST_AUTO_TEST_CASE(read_buffer_prepare_error)
-{
-   using boost::redis::detail::read_buffer;
-
-   read_buffer buf;
-
-   // Usual case, max size is bigger then requested size.
-   buf.set_config({10, 10});
-   auto ec = buf.prepare();
-   BOOST_TEST(!ec);
-   buf.commit(10);
-
-   // Corner case, max size is equal to the requested size.
-   buf.set_config({10, 20});
-   ec = buf.prepare();
-   BOOST_TEST(!ec);
-   buf.commit(10);
-   buf.consume(20);
-
-   auto const tmp = buf;
-
-   // Error case, max size is smaller to the requested size.
-   buf.set_config({10, 9});
-   ec = buf.prepare();
-   BOOST_TEST(ec == error_code{boost::redis::error::exceeds_maximum_read_buffer_size});
-
-   // Check that an error call has no side effects.
-   auto const res = buf == tmp;
-   BOOST_TEST(res);
-}
-
-BOOST_AUTO_TEST_CASE(read_buffer_prepare_consume_only_committed_data)
-{
-   using boost::redis::detail::read_buffer;
-
-   read_buffer buf;
-
-   buf.set_config({10, 10});
-   auto ec = buf.prepare();
-   BOOST_TEST(!ec);
-
-   auto res = buf.consume(5);
-
-   // No data has been committed yet so nothing can be consummed.
-   BOOST_CHECK_EQUAL(res.consumed, 0u);
-
-   // If nothing was consumed, nothing got rotated.
-   BOOST_CHECK_EQUAL(res.rotated, 0u);
-
-   buf.commit(10);
-   res = buf.consume(5);
-
-   // All five bytes should have been consumed.
-   BOOST_CHECK_EQUAL(res.consumed, 5u);
-
-   // We added a total of 10 bytes and consumed 5, that means, 5 were
-   // rotated.
-   BOOST_CHECK_EQUAL(res.rotated, 5u);
-
-   res = buf.consume(7);
-
-   // Only the remaining five bytes can be consumed
-   BOOST_CHECK_EQUAL(res.consumed, 5u);
-
-   // No bytes to rotated.
-   BOOST_CHECK_EQUAL(res.rotated, 0u);
-}
-
-BOOST_AUTO_TEST_CASE(read_buffer_check_buffer_size)
-{
-   using boost::redis::detail::read_buffer;
-
-   read_buffer buf;
-
-   buf.set_config({10, 10});
-   auto ec = buf.prepare();
-   BOOST_TEST(!ec);
-
-   BOOST_CHECK_EQUAL(buf.get_prepared().size(), 10u);
-}
-
 BOOST_AUTO_TEST_CASE(check_counter_adapter)
 {
    using boost::redis::any_adapter;
@@ -313,3 +253,39 @@ BOOST_AUTO_TEST_CASE(check_counter_adapter)
    BOOST_CHECK_EQUAL(node, 7);
    BOOST_CHECK_EQUAL(done, 1);
 }
+
+BOOST_AUTO_TEST_CASE(generic_flat_response_simple_error)
+{
+   generic_flat_response resp;
+
+   char const* wire = "-Error\r\n";
+
+   error_code ec;
+   deserialize(wire, adapt2(resp), ec);
+   BOOST_CHECK_EQUAL(ec, error_code{});
+
+   BOOST_TEST(!resp.has_value());
+   BOOST_TEST(resp.has_error());
+   auto const error = resp.error();
+
+   BOOST_CHECK_EQUAL(error.data_type, boost::redis::resp3::type::simple_error);
+   BOOST_CHECK_EQUAL(error.diagnostic, std::string{"Error"});
+}
+
+BOOST_AUTO_TEST_CASE(generic_flat_response_blob_error)
+{
+   generic_flat_response resp;
+
+   char const* wire = "!5\r\nError\r\n";
+
+   error_code ec;
+   deserialize(wire, adapt2(resp), ec);
+   BOOST_CHECK_EQUAL(ec, error_code{});
+
+   BOOST_TEST(!resp.has_value());
+   BOOST_TEST(resp.has_error());
+   auto const error = resp.error();
+
+   BOOST_CHECK_EQUAL(error.data_type, boost::redis::resp3::type::blob_error);
+   BOOST_CHECK_EQUAL(error.diagnostic, std::string{"Error"});
+}

test/test_multiplexer.cpp

@@ -15,6 +15,7 @@
 #include <boost/assert/source_location.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "print_node.hpp"
 #include "sansio_utils.hpp"
 
 #include <iostream>
@@ -33,17 +34,6 @@ using boost::redis::response;
 using boost::redis::any_adapter;
 using boost::system::error_code;
 
-namespace boost::redis::resp3 {
-
-std::ostream& operator<<(std::ostream& os, node const& nd)
-{
-   return os << "node{ .data_type=" << to_string(nd.data_type)
-             << ", .aggregate_size=" << nd.aggregate_size << ", .depth=" << nd.depth
-             << ", .value=" << nd.value << "}";
-}
-
-}  // namespace boost::redis::resp3
-
 namespace boost::redis::detail {
 
 std::ostream& operator<<(std::ostream& os, consume_result v)

test/test_parse_sentinel_response.cpp

@@ -0,0 +1,727 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/connection_state.hpp>
+#include <boost/redis/impl/sentinel_utils.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/resp3/parser.hpp>
+
+#include <boost/assert/source_location.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/error_code.hpp>
+
+#include "sansio_utils.hpp"
+
+#include <initializer_list>
+#include <ostream>
+#include <string_view>
+#include <vector>
+
+using namespace boost::redis;
+using detail::nodes_from_resp3;
+using detail::parse_sentinel_response;
+using detail::sentinel_response;
+using boost::system::error_code;
+
+// Operators
+namespace boost::redis {
+
+std::ostream& operator<<(std::ostream& os, const address& addr)
+{
+   return os << "address{ .host=" << addr.host << ", .port=" << addr.port << " }";
+}
+
+}  // namespace boost::redis
+
+namespace {
+
+struct fixture {
+   sentinel_response resp{
+      "leftover",
+      {"leftover_host", "6543"},
+      {address()},
+      {address()},
+   };
+
+   void check_response(
+      const address& expected_master_addr,
+      boost::span<const address> expected_replicas,
+      boost::span<const address> expected_sentinels,
+      boost::source_location loc = BOOST_CURRENT_LOCATION) const
+   {
+      if (!BOOST_TEST_EQ(resp.diagnostic, ""))
+         std::cerr << "Called from " << loc << std::endl;
+      if (!BOOST_TEST_EQ(resp.master_addr, expected_master_addr))
+         std::cerr << "Called from " << loc << std::endl;
+      if (!BOOST_TEST_ALL_EQ(
+             resp.replicas.begin(),
+             resp.replicas.end(),
+             expected_replicas.begin(),
+             expected_replicas.end()))
+         std::cerr << "Called from " << loc << std::endl;
+      if (!BOOST_TEST_ALL_EQ(
+             resp.sentinels.begin(),
+             resp.sentinels.end(),
+             expected_sentinels.begin(),
+             expected_sentinels.end()))
+         std::cerr << "Called from " << loc << std::endl;
+   }
+};
+
+// Usual response when asking for a master
+void test_master()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*2\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$2\r\nip\r\n$8\r\nhost.one\r\n$4\r\nport\r\n$5\r\n26380\r\n"
+            "$5\r\nrunid\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n334\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$2\r\nip\r\n$8\r\nhost.two\r\n$4\r\nport\r\n$5\r\n26381\r\n"
+            "$5\r\nrunid\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n134\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n",
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::master, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_sentinels[] = {
+      {"host.one", "26380"},
+      {"host.two", "26381"},
+   };
+   fix.check_response({"localhost", "6380"}, {}, expected_sentinels);
+}
+
+// Works correctly even if no Sentinels are present
+void test_master_no_sentinels()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::master, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+   fix.check_response({"localhost", "6380"}, {}, {});
+}
+
+// The responses corresponding to the user-defined setup request are ignored
+void test_master_setup_request()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "+OK\r\n",
+      "%6\r\n$6\r\nserver\r\n$5\r\nredis\r\n$7\r\nversion\r\n$5\r\n7.4.2\r\n$5\r\nproto\r\n:3\r\n$2\r\nid\r\n:3\r\n$4\r\nmode\r\n$8\r\nsentinel\r\n$7\r\nmodules\r\n*0\r\n",
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*2\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$2\r\nip\r\n$8\r\nhost.one\r\n$4\r\nport\r\n$5\r\n26380\r\n"
+            "$5\r\nrunid\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n334\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$2\r\nip\r\n$8\r\nhost.two\r\n$4\r\nport\r\n$5\r\n26381\r\n"
+            "$5\r\nrunid\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n134\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n",
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::master, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_sentinels[] = {
+      {"host.one", "26380"},
+      {"host.two", "26381"},
+   };
+   fix.check_response({"localhost", "6380"}, {}, expected_sentinels);
+}
+
+// IP and port can be out of order
+void test_master_ip_port_out_of_order()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*1\r\n"
+         "%2\r\n"
+            "$4\r\nport\r\n$5\r\n26380\r\n$2\r\nip\r\n$8\r\nhost.one\r\n"
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::master, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_sentinels[] = {
+      {"host.one", "26380"},
+   };
+   fix.check_response({"localhost", "6380"}, {}, expected_sentinels);
+}
+
+// Usual response when asking for a replica
+void test_replica()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*2\r\n"
+         "%21\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6381\r\n$2\r\nip\r\n$9\r\nsome.host\r\n$4\r\nport\r\n$4\r\n6381\r\n"
+            "$5\r\nrunid\r\n$40\r\ncdfa33e2d39958c0b10c0391c0c3d4ab096edfeb\r\n$5\r\nflags\r\n$5\r\nslave\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n134\r\n$15\r\nlast-ping-reply\r\n$3\r\n134\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$12\r\ninfo-refresh\r\n$4\r\n5302\r\n$13\r\nrole-reported\r\n$5\r\nslave\r\n$18\r\nrole-reported-time\r\n$6\r\n442121\r\n"
+            "$21\r\nmaster-link-down-time\r\n$1\r\n0\r\n$18\r\nmaster-link-status\r\n$2\r\nok\r\n$11\r\nmaster-host\r\n$9\r\nlocalhost\r\n"
+            "$11\r\nmaster-port\r\n$4\r\n6380\r\n$14\r\nslave-priority\r\n$3\r\n100\r\n$17\r\nslave-repl-offset\r\n$5\r\n29110\r\n"
+            "$17\r\nreplica-announced\r\n$1\r\n1\r\n"
+         "%21\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6382\r\n$2\r\nip\r\n$9\r\ntest.host\r\n$4\r\nport\r\n$4\r\n6382\r\n"
+            "$5\r\nrunid\r\n$40\r\n11bfea62c25316e211fdf0e1ccd2dbd920e90815\r\n$5\r\nflags\r\n$5\r\nslave\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n134\r\n$15\r\nlast-ping-reply\r\n$3\r\n134\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$12\r\ninfo-refresh\r\n$4\r\n5302\r\n$13\r\nrole-reported\r\n$5\r\nslave\r\n$18\r\nrole-reported-time\r\n$6\r\n442132\r\n"
+            "$21\r\nmaster-link-down-time\r\n$1\r\n0\r\n$18\r\nmaster-link-status\r\n$2\r\nok\r\n$11\r\nmaster-host\r\n$9\r\nlocalhost\r\n"
+            "$11\r\nmaster-port\r\n$4\r\n6380\r\n$14\r\nslave-priority\r\n$3\r\n100\r\n$17\r\nslave-repl-offset\r\n$5\r\n29110\r\n"
+            "$17\r\nreplica-announced\r\n$1\r\n1\r\n",
+      "*2\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$2\r\nip\r\n$8\r\nhost.one\r\n$4\r\nport\r\n$5\r\n26380\r\n"
+            "$5\r\nrunid\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n334\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n"
+         "%14\r\n"
+            "$4\r\nname\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$2\r\nip\r\n$8\r\nhost.two\r\n$4\r\nport\r\n$5\r\n26381\r\n"
+            "$5\r\nrunid\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$5\r\nflags\r\n$8\r\nsentinel\r\n"
+            "$21\r\nlink-pending-commands\r\n$1\r\n0\r\n$13\r\nlink-refcount\r\n$1\r\n1\r\n$14\r\nlast-ping-sent\r\n$1\r\n0\r\n"
+            "$18\r\nlast-ok-ping-reply\r\n$3\r\n696\r\n$15\r\nlast-ping-reply\r\n$3\r\n696\r\n$23\r\ndown-after-milliseconds\r\n$5\r\n10000\r\n"
+            "$18\r\nlast-hello-message\r\n$3\r\n134\r\n$12\r\nvoted-leader\r\n$1\r\n?\r\n$18\r\nvoted-leader-epoch\r\n$1\r\n0\r\n",
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::replica, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_replicas[] = {
+      {"some.host", "6381"},
+      {"test.host", "6382"},
+   };
+   const address expected_sentinels[] = {
+      {"host.one", "26380"},
+      {"host.two", "26381"},
+   };
+   fix.check_response({"localhost", "6380"}, expected_replicas, expected_sentinels);
+}
+
+// Like the master case
+void test_replica_no_sentinels()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*2\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6381\r\n$2\r\nip\r\n$9\r\nsome.host\r\n$4\r\nport\r\n$4\r\n6381\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6382\r\n$2\r\nip\r\n$9\r\ntest.host\r\n$4\r\nport\r\n$4\r\n6382\r\n",
+      "*0\r\n"
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::replica, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_replicas[] = {
+      {"some.host", "6381"},
+      {"test.host", "6382"},
+   };
+   fix.check_response({"localhost", "6380"}, expected_replicas, {});
+}
+
+// Asking for replicas, but there is none
+void test_replica_no_replicas()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+      "*0\r\n",
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::replica, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   fix.check_response({"localhost", "6380"}, {}, {});
+}
+
+// Setup requests work with replicas, too
+void test_replica_setup_request()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n+OK\r\n+OK\r\n",
+      "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+      "*2\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6381\r\n$2\r\nip\r\n$9\r\nsome.host\r\n$4\r\nport\r\n$4\r\n6381\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$14\r\nlocalhost:6382\r\n$2\r\nip\r\n$9\r\ntest.host\r\n$4\r\nport\r\n$4\r\n6382\r\n",
+      "*2\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$40\r\nf14ef06a8a478cdd66ded467ec18accd2a24b731\r\n$2\r\nip\r\n$8\r\nhost.one\r\n$4\r\nport\r\n$5\r\n26380\r\n"
+         "%3\r\n"
+            "$4\r\nname\r\n$40\r\nf9b54e79e2e7d3f17ad60527504191ec8a861f27\r\n$2\r\nip\r\n$8\r\nhost.two\r\n$4\r\nport\r\n$5\r\n26381\r\n"
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::replica, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_replicas[] = {
+      {"some.host", "6381"},
+      {"test.host", "6382"},
+   };
+   const address expected_sentinels[] = {
+      {"host.one", "26380"},
+      {"host.two", "26381"},
+   };
+   fix.check_response({"localhost", "6380"}, expected_replicas, expected_sentinels);
+}
+
+// IP and port can be out of order
+void test_replica_ip_port_out_of_order()
+{
+   // Setup
+   fixture fix;
+   auto nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6389\r\n",
+      "*1\r\n"
+         "%2\r\n"
+            "$4\r\nport\r\n$4\r\n6381\r\n$2\r\nip\r\n$9\r\nsome.host\r\n",
+      "*0\r\n"
+      // clang-format on
+   });
+
+   // Call the function
+   auto ec = parse_sentinel_response(nodes, role::replica, fix.resp);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Check
+   const address expected_replicas[] = {
+      {"some.host", "6381"},
+   };
+   fix.check_response({"test.host", "6389"}, expected_replicas, {});
+}
+
+void test_errors()
+{
+   const struct {
+      std::string_view name;
+      role server_role;
+      std::vector<std::string_view> responses;
+      std::string_view expected_diagnostic;
+      error_code expected_ec;
+   } test_cases[]{
+      // clang-format off
+      {
+         // A RESP3 simple error
+         "setup_error_simple",
+         role::master,
+         {
+            "-WRONGPASS invalid username-password pair or user is disabled.\r\n",
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*0\r\n",
+         },
+         "WRONGPASS invalid username-password pair or user is disabled.",
+         error::resp3_simple_error
+      },
+      {
+         // A RESP3 blob error
+         "setup_error_blob",
+         role::master,
+         {
+            "!3\r\nBad\r\n",
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*0\r\n",
+         },
+         "Bad",
+         error::resp3_blob_error
+      },
+      {
+         // Errors in intermediate nodes of the user-supplied request
+         "setup_error_intermediate",
+         role::master,
+         {
+            "+OK\r\n",
+            "-Something happened!\r\n",
+            "+OK\r\n",
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*0\r\n",
+         },
+         "Something happened!",
+         error::resp3_simple_error
+      },
+      {
+         // Only the first error is processed (e.g. auth failure may cause subsequent cmds to fail)
+         "setup_error_intermediate",
+         role::master,
+         {
+            "-Something happened!\r\n",
+            "-Something worse happened!\r\n",
+            "-Bad\r\n",
+            "-Worse\r\n",
+         },
+         "Something happened!",
+         error::resp3_simple_error
+      },
+      {
+         // This works for replicas, too
+         "setup_error_replicas",
+         role::replica,
+         {
+            "-Something happened!\r\n",
+            "-Something worse happened!\r\n",
+            "-Bad\r\n",
+            "-Worse\r\n",
+         },
+         "Something happened!",
+         error::resp3_simple_error
+      },
+
+      // SENTINEL GET-MASTER-ADDR-BY-NAME
+      {
+         // Unknown master. This returns NULL and causes SENTINEL SENTINELS to fail
+         "getmasteraddr_unknown_master",
+         role::master,
+         {
+            "_\r\n",
+            "-ERR Unknown master\r\n",
+         },
+         "",
+         error::resp3_null
+      },
+      {
+         // The request errors for any other reason
+         "getmasteraddr_error",
+         role::master,
+         {
+            "-ERR something happened\r\n",
+            "*0\r\n",
+         },
+         "ERR something happened",
+         error::resp3_simple_error
+      },
+      {
+         // Same, for replicas
+         "getmasteraddr_unknown_master_replica",
+         role::replica,
+         {
+            "_\r\n",
+            "-ERR Unknown master\r\n",
+            "-ERR Unknown master\r\n",
+         },
+         "",
+         error::resp3_null
+      },
+      {
+         // Root node should be a list
+         "getmasteraddr_not_array",
+         role::master,
+         {
+            "+OK\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_array
+      },
+      {
+         // Root node should have exactly 2 elements
+         "getmasteraddr_array_size_1",
+         role::master,
+         {
+            "*1\r\n$5\r\nhello\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::incompatible_size
+      },
+      {
+         // Root node should have exactly 2 elements
+         "getmasteraddr_array_size_3",
+         role::master,
+         {
+            "*3\r\n$5\r\nhello\r\n$3\r\nbye\r\n$3\r\nabc\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::incompatible_size
+      },
+      {
+         // IP should be a string
+         "getmasteraddr_ip_not_string",
+         role::master,
+         {
+            "*2\r\n+OK\r\n$5\r\nhello\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+      {
+         // Port should be a string
+         "getmasteraddr_port_not_string",
+         role::master,
+         {
+            "*2\r\n$5\r\nhello\r\n+OK\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+
+      // SENTINEL SENTINELS
+      {
+         // The request errors
+         "sentinels_error",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "-ERR something went wrong\r\n",
+         },
+         "ERR something went wrong",
+         error::resp3_simple_error
+      },
+      {
+         // The root node should be an array
+         "sentinels_not_array",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "+OK\r\n",
+         },
+         "",
+         error::expects_resp3_array
+      },
+      {
+         // Each Sentinel object should be a map
+         "sentinels_subobject_not_map",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n*1\r\n$9\r\nlocalhost\r\n",
+         },
+         "",
+         error::expects_resp3_map
+      },
+      {
+         // Keys in the Sentinel object should be strings
+         "sentinels_keys_not_strings",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n*0\r\n$5\r\nhello\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+      {
+         // Values in the Sentinel object should be strings
+         "sentinels_keys_not_strings",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$5\r\nhello\r\n*1\r\n+OK\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+      {
+         "sentinels_ip_not_found",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$4\r\nport\r\n$4\r\n6380\r\n",
+         },
+         "",
+         error::empty_field
+      },
+      {
+         "sentinels_port_not_found",
+         role::master,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$2\r\nip\r\n$9\r\nlocalhost\r\n",
+         },
+         "",
+         error::empty_field
+      },
+
+      // SENTINEL REPLICAS
+      {
+         // The request errors
+         "replicas_error",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "-ERR something went wrong\r\n",
+            "*0\r\n",
+         },
+         "ERR something went wrong",
+         error::resp3_simple_error
+      },
+      {
+         // The root node should be an array
+         "replicas_not_array",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "+OK\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_array
+      },
+      {
+         // Each replica object should be a map
+         "replicas_subobject_not_map",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n*1\r\n$9\r\nlocalhost\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_map
+      },
+      {
+         // Keys in the replica object should be strings
+         "replicas_keys_not_strings",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n*0\r\n$5\r\nhello\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+      {
+         // Values in the replica object should be strings
+         "replicas_keys_not_strings",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$5\r\nhello\r\n*1\r\n+OK\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::expects_resp3_string
+      },
+      {
+         "replicas_ip_not_found",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$4\r\nport\r\n$4\r\n6380\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::empty_field
+      },
+      {
+         "replicas_port_not_found",
+         role::replica,
+         {
+            "*2\r\n$9\r\nlocalhost\r\n$4\r\n6380\r\n",
+            "*1\r\n%1\r\n$2\r\nip\r\n$9\r\nlocalhost\r\n",
+            "*0\r\n",
+         },
+         "",
+         error::empty_field
+      }
+
+      // clang-format on
+   };
+
+   for (const auto& tc : test_cases) {
+      // Setup
+      std::cerr << "Running error test case: " << tc.name << std::endl;
+      fixture fix;
+      auto nodes = nodes_from_resp3(tc.responses);
+
+      // Call the function
+      auto ec = parse_sentinel_response(nodes, tc.server_role, fix.resp);
+      BOOST_TEST_EQ(ec, tc.expected_ec);
+      BOOST_TEST_EQ(fix.resp.diagnostic, tc.expected_diagnostic);
+   }
+}
+
+}  // namespace
+
+int main()
+{
+   test_master();
+   test_master_no_sentinels();
+   test_master_setup_request();
+   test_master_ip_port_out_of_order();
+
+   test_replica();
+   test_replica_no_sentinels();
+   test_replica_no_replicas();
+   test_replica_setup_request();
+   test_replica_ip_port_out_of_order();
+
+   test_errors();
+
+   return boost::report_errors();
+}

test/test_read_buffer.cpp

@@ -0,0 +1,102 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/detail/read_buffer.hpp>
+#include <boost/redis/error.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/error_code.hpp>
+
+using namespace boost::redis;
+using detail::read_buffer;
+using boost::system::error_code;
+
+namespace {
+
+void test_prepare_error()
+{
+   read_buffer buf;
+
+   // Usual case, max size is bigger then requested size.
+   buf.set_config({10, 10});
+   auto ec = buf.prepare();
+   BOOST_TEST_EQ(ec, error_code());
+   buf.commit(10);
+
+   // Corner case, max size is equal to the requested size.
+   buf.set_config({10, 20});
+   ec = buf.prepare();
+   BOOST_TEST_EQ(ec, error_code());
+   buf.commit(10);
+   buf.consume(20);
+
+   auto const tmp = buf;
+
+   // Error case, max size is smaller to the requested size.
+   buf.set_config({10, 9});
+   ec = buf.prepare();
+   BOOST_TEST_EQ(ec, error_code{error::exceeds_maximum_read_buffer_size});
+
+   // Check that an error call has no side effects.
+   BOOST_TEST(buf == tmp);
+}
+
+void test_prepare_consume_only_committed_data()
+{
+   read_buffer buf;
+
+   buf.set_config({10, 10});
+   auto ec = buf.prepare();
+   BOOST_TEST(!ec);
+
+   auto res = buf.consume(5);
+
+   // No data has been committed yet so nothing can be consummed.
+   BOOST_TEST_EQ(res.consumed, 0u);
+
+   // If nothing was consumed, nothing got rotated.
+   BOOST_TEST_EQ(res.rotated, 0u);
+
+   buf.commit(10);
+   res = buf.consume(5);
+
+   // All five bytes should have been consumed.
+   BOOST_TEST_EQ(res.consumed, 5u);
+
+   // We added a total of 10 bytes and consumed 5, that means, 5 were
+   // rotated.
+   BOOST_TEST_EQ(res.rotated, 5u);
+
+   res = buf.consume(7);
+
+   // Only the remaining five bytes can be consumed
+   BOOST_TEST_EQ(res.consumed, 5u);
+
+   // No bytes to rotated.
+   BOOST_TEST_EQ(res.rotated, 0u);
+}
+
+void test_check_buffer_size()
+{
+   read_buffer buf;
+
+   buf.set_config({10, 10});
+   auto ec = buf.prepare();
+   BOOST_TEST_EQ(ec, error_code());
+
+   BOOST_TEST_EQ(buf.get_prepared().size(), 10u);
+}
+
+}  // namespace
+
+int main()
+{
+   test_prepare_error();
+   test_prepare_consume_only_committed_data();
+   test_check_buffer_size();
+
+   return boost::report_errors();
+}

test/test_request.cpp

@@ -14,8 +14,6 @@
 
 using boost::redis::request;
 
-// TODO: Serialization.
-
 namespace {
 
 void test_push_no_args()

test/test_run_fsm.cpp

@@ -39,6 +39,7 @@ static const char* to_string(run_action_type value)
    switch (value) {
       case run_action_type::done:                  return "run_action_type::done";
       case run_action_type::immediate:             return "run_action_type::immediate";
+      case run_action_type::sentinel_resolve:      return "run_action_type::sentinel_resolve";
       case run_action_type::connect:               return "run_action_type::connect";
       case run_action_type::parallel_group:        return "run_action_type::parallel_group";
       case run_action_type::cancel_receive:        return "run_action_type::cancel_receive";
@@ -142,6 +143,30 @@ void test_config_error_unix_ssl()
    });
 }
 
+void test_config_error_unix_sentinel()
+{
+   // Setup
+   config cfg;
+   cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   cfg.unix_socket = "/var/sock";
+   fixture fix{std::move(cfg)};
+
+   // Launching the operation fails immediately
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::immediate);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::sentinel_unix_sockets_unsupported));
+
+   // Log
+   fix.check_log({
+      {logger::level::err,
+       "Invalid configuration: The configuration specified UNIX sockets with Sentinel, which is "
+       "not supported. [boost.redis:28]"},
+   });
+}
+
 // An error in connect with reconnection enabled triggers a reconnection
 void test_connect_error()
 {
@@ -162,10 +187,83 @@ void test_connect_error()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
    BOOST_TEST_EQ(act, run_action_type::parallel_group);
 
-   // Run doesn't log, it's the subordinate tasks that do
-   fix.check_log({});
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Failed to connect to Redis server at 127.0.0.1:6379 (TLS disabled): Connect timeout. [boost.redis:18]"},
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"          },
+      // clang-format on
+   });
 }
 
+// Check logs for other transport types
+void test_connect_error_ssl()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.addr = {"my_hostname", "10000"};
+   fix.st.cfg.use_ssl = true;
+
+   // Launch the operation
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // Connect errors. We sleep and try to connect again
+   act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::wait_for_reconnection);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // This time we succeed and we launch the parallel group
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::parallel_group);
+
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at my_hostname:10000 (TLS enabled)"  },
+      {logger::level::info, "Failed to connect to Redis server at my_hostname:10000 (TLS enabled): Connect timeout. [boost.redis:18]"},
+      {logger::level::info, "Trying to connect to Redis server at my_hostname:10000 (TLS enabled)"  },
+      {logger::level::info, "Connected to Redis server at my_hostname:10000 (TLS enabled)"          },
+      // clang-format on
+   });
+}
+
+#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
+void test_connect_error_unix()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.unix_socket = "/tmp/sock";
+
+   // Launch the operation
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // Connect errors. We sleep and try to connect again
+   act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::wait_for_reconnection);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // This time we succeed and we launch the parallel group
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::parallel_group);
+
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at '/tmp/sock'"  },
+      {logger::level::info, "Failed to connect to Redis server at '/tmp/sock': Connect timeout. [boost.redis:18]"},
+      {logger::level::info, "Trying to connect to Redis server at '/tmp/sock'"  },
+      {logger::level::info, "Connected to Redis server at '/tmp/sock'"          },
+      // clang-format on
+   });
+}
+#endif
+
 // An error in connect without reconnection enabled makes the operation finish
 void test_connect_error_no_reconnect()
 {
@@ -180,8 +278,13 @@ void test_connect_error_no_reconnect()
    act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
    BOOST_TEST_EQ(act, error_code(error::connect_timeout));
 
-   // Run doesn't log, it's the subordinate tasks that do
-   fix.check_log({});
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Failed to connect to Redis server at 127.0.0.1:6379 (TLS disabled): Connect timeout. [boost.redis:18]"},
+      // clang-format on
+   });
 }
 
 // A cancellation in connect makes the operation finish even with reconnection enabled
@@ -198,9 +301,10 @@ void test_connect_cancel()
    act = fix.fsm.resume(fix.st, asio::error::operation_aborted, cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (1)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::debug, "Run: cancelled (1)"                                                }
    });
 }
 
@@ -218,9 +322,10 @@ void test_connect_cancel_edge()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (1)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::debug, "Run: cancelled (1)"                                                }
    });
 }
 
@@ -247,8 +352,13 @@ void test_parallel_group_error()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
    BOOST_TEST_EQ(act, run_action_type::parallel_group);
 
-   // Run doesn't log, it's the subordinate tasks that do
-   fix.check_log({});
+   // Log
+   fix.check_log({
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+   });
 }
 
 // An error in the parallel group makes the operation exit if reconnection is disabled
@@ -269,8 +379,11 @@ void test_parallel_group_error_no_reconnect()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
    BOOST_TEST_EQ(act, error_code(error::empty_field));
 
-   // Run doesn't log, it's the subordinate tasks that do
-   fix.check_log({});
+   // Log
+   fix.check_log({
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+   });
 }
 
 // A cancellation in the parallel group makes it exit, even if reconnection is enabled.
@@ -292,9 +405,11 @@ void test_parallel_group_cancel()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (2)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::debug, "Run: cancelled (2)"                                                }
    });
 }
 
@@ -315,9 +430,11 @@ void test_parallel_group_cancel_no_reconnect()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (2)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::debug, "Run: cancelled (2)"                                                }
    });
 }
 
@@ -343,9 +460,11 @@ void test_wait_cancel()
    act = fix.fsm.resume(fix.st, asio::error::operation_aborted, cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (3)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::debug, "Run: cancelled (3)"                                                }
    });
 }
 
@@ -370,9 +489,11 @@ void test_wait_cancel_edge()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // We log on cancellation only
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (3)"}
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::debug, "Run: cancelled (3)"                                                }
    });
 }
 
@@ -409,9 +530,16 @@ void test_several_reconnections()
    act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
    BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
 
-   // The cancellation was logged
+   // Log
    fix.check_log({
-      {logger::level::debug, "Run: cancelled (2)"}
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Failed to connect to Redis server at 127.0.0.1:6379 (TLS disabled): Connect timeout. [boost.redis:18]"},
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"          },
+      {logger::level::info,  "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
+      {logger::level::debug, "Run: cancelled (2)"                                                }  // clang-format on
    });
 }
 
@@ -481,7 +609,11 @@ void test_setup_request_success()
 
    // Check log
    fix.check_log({
-      {logger::level::info, "Setup request execution: success"}
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"          },
+      {logger::level::info, "Setup request execution: success"},
+      // clang-format on
    });
 }
 
@@ -501,8 +633,13 @@ void test_setup_request_empty()
    // Nothing was added to the multiplexer
    BOOST_TEST_EQ(fix.st.mpx.prepare_write(), 0u);
 
-   // Check log
-   fix.check_log({});
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"  },
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"          },
+      // clang-format on
+   });
 }
 
 // A server error would cause the reader to exit
@@ -510,7 +647,7 @@ void test_setup_request_server_error()
 {
    // Setup
    fixture fix;
-   fix.st.setup_diagnostic = "leftover";  // simulate a leftover from previous runs
+   fix.st.diagnostic = "leftover";  // simulate a leftover from previous runs
    fix.st.cfg.setup.clear();
    fix.st.cfg.setup.push("HELLO", 3);
 
@@ -533,9 +670,147 @@ void test_setup_request_server_error()
 
    // Check log
    fix.check_log({
+      {logger::level::info, "Trying to connect to Redis server at 127.0.0.1:6379 (TLS disabled)"},
+      {logger::level::info, "Connected to Redis server at 127.0.0.1:6379 (TLS disabled)"        },
       {logger::level::info,
        "Setup request execution: The server response to the setup request sent during connection "
-       "establishment contains an error. [boost.redis:23] (ERR: wrong command)"}
+       "establishment contains an error. [boost.redis:23] (ERR: wrong command)"                 }
+   });
+}
+
+// When using Sentinel, reconnection works normally
+void test_sentinel_reconnection()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+
+   // Resolve succeeds, and a connection is attempted
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+   fix.st.cfg.addr = {"host1", "1000"};
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // This errors, so we sleep and resolve again
+   act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::wait_for_reconnection);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+   fix.st.cfg.addr = {"host2", "2000"};
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::parallel_group);
+
+   // Sentinel involves always a setup request containing the role check. Run it.
+   BOOST_TEST_EQ(fix.st.mpx.prepare_write(), 1u);
+   BOOST_TEST(fix.st.mpx.commit_write(fix.st.mpx.get_write_buffer().size()));
+   read(fix.st.mpx, "*1\r\n$6\r\nmaster\r\n");
+   error_code ec;
+   auto res = fix.st.mpx.consume(ec);
+   BOOST_TEST_EQ(ec, error_code());
+   BOOST_TEST(res.first == detail::consume_result::got_response);
+
+   // The parallel group errors, so we sleep and resolve again
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::cancel_receive);
+   act = fix.fsm.resume(fix.st, error::write_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::wait_for_reconnection);
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+   fix.st.cfg.addr = {"host3", "3000"};
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // Cancel
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Log
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to connect to Redis server at host1:1000 (TLS disabled)"},
+      {logger::level::info,  "Failed to connect to Redis server at host1:1000 (TLS disabled): Connect timeout. [boost.redis:18]"},
+      {logger::level::info,  "Trying to connect to Redis server at host2:2000 (TLS disabled)"},
+      {logger::level::info,  "Connected to Redis server at host2:2000 (TLS disabled)"},
+      {logger::level::info,  "Setup request execution: success"},
+      {logger::level::info,  "Trying to connect to Redis server at host3:3000 (TLS disabled)"},
+      {logger::level::debug, "Run: cancelled (1)"},
+      // clang-format on
+   });
+}
+
+// If the Sentinel resolve operation errors, we try again
+void test_sentinel_resolve_error()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+
+   // Start the Sentinel resolve operation
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+
+   // It fails with an error, so we go to sleep
+   act = fix.fsm.resume(fix.st, error::sentinel_resolve_failed, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::wait_for_reconnection);
+
+   // Retrying it succeeds
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+   fix.st.cfg.addr = {"myhost", "10000"};
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::connect);
+
+   // Log
+   fix.check_log({
+      {logger::level::info, "Trying to connect to Redis server at myhost:10000 (TLS disabled)"},
+   });
+}
+
+// The reconnection setting affects Sentinel reconnection, too
+void test_sentinel_resolve_error_no_reconnect()
+{
+   // Setup
+   fixture fix{config_no_reconnect()};
+   fix.st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+
+   // Start the Sentinel resolve operation
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+
+   // It fails with an error, so we exit
+   act = fix.fsm.resume(fix.st, error::sentinel_resolve_failed, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::sentinel_resolve_failed));
+
+   // Log
+   fix.check_log({});
+}
+
+void test_sentinel_resolve_cancel()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+
+   // Start the Sentinel resolve operation
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, run_action_type::sentinel_resolve);
+   act = fix.fsm.resume(fix.st, asio::error::operation_aborted, cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Log
+   fix.check_log({
+      {logger::level::debug, "Run: cancelled (4)"},
    });
 }
 
@@ -547,8 +822,13 @@ int main()
    test_config_error_unix();
 #endif
    test_config_error_unix_ssl();
+   test_config_error_unix_sentinel();
 
    test_connect_error();
+   test_connect_error_ssl();
+#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
+   test_connect_error_unix();
+#endif
    test_connect_error_no_reconnect();
    test_connect_cancel();
    test_connect_cancel_edge();
@@ -568,5 +848,10 @@ int main()
    test_setup_request_empty();
    test_setup_request_server_error();
 
+   test_sentinel_reconnection();
+   test_sentinel_resolve_error();
+   test_sentinel_resolve_error_no_reconnect();
+   test_sentinel_resolve_cancel();
+
    return boost::report_errors();
 }

test/test_sentinel_resolve_fsm.cpp

@@ -0,0 +1,682 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/connection_state.hpp>
+#include <boost/redis/detail/sentinel_resolve_fsm.hpp>
+#include <boost/redis/error.hpp>
+
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/error_code.hpp>
+
+#include "sansio_utils.hpp"
+
+#include <iterator>
+
+using namespace boost::redis;
+namespace asio = boost::asio;
+using detail::sentinel_resolve_fsm;
+using detail::sentinel_action;
+using detail::connection_state;
+using detail::nodes_from_resp3;
+using boost::system::error_code;
+using boost::asio::cancellation_type_t;
+
+static char const* to_string(sentinel_action::type t)
+{
+   switch (t) {
+      case sentinel_action::type::done:    return "sentinel_action::type::done";
+      case sentinel_action::type::connect: return "sentinel_action::type::connect";
+      case sentinel_action::type::request: return "sentinel_action::type::request";
+      default:                             return "sentinel_action::type::<invalid type>";
+   }
+}
+
+// Operators
+namespace boost::redis::detail {
+
+std::ostream& operator<<(std::ostream& os, sentinel_action::type type)
+{
+   os << to_string(type);
+   return os;
+}
+
+bool operator==(sentinel_action lhs, sentinel_action rhs) noexcept
+{
+   if (lhs.get_type() != rhs.get_type())
+      return false;
+   else if (lhs.get_type() == sentinel_action::type::done)
+      return lhs.error() == rhs.error();
+   else if (lhs.get_type() == sentinel_action::type::connect)
+      return lhs.connect_addr() == rhs.connect_addr();
+   else
+      return true;
+}
+
+std::ostream& operator<<(std::ostream& os, sentinel_action act)
+{
+   os << "exec_action{ .type=" << act.get_type();
+   if (act.get_type() == sentinel_action::type::done)
+      os << ", .error=" << act.error();
+   else if (act.get_type() == sentinel_action::type::connect)
+      os << ", .addr=" << act.connect_addr().host << ":" << act.connect_addr().port;
+   return os << " }";
+}
+
+}  // namespace boost::redis::detail
+
+namespace boost::redis {
+
+std::ostream& operator<<(std::ostream& os, const address& addr)
+{
+   return os << "address{ .host=" << addr.host << ", .port=" << addr.port << " }";
+}
+
+}  // namespace boost::redis
+
+namespace {
+
+struct fixture : detail::log_fixture {
+   connection_state st{{make_logger()}};
+   sentinel_resolve_fsm fsm;
+
+   fixture()
+   {
+      st.sentinels = {
+         {"host1", "1000"},
+         {"host2", "2000"},
+         {"host3", "3000"},
+      };
+      st.cfg.sentinel.addresses = {
+         {"host1", "1000"},
+         {"host4", "4000"},
+      };
+      st.cfg.sentinel.master_name = "mymaster";
+   }
+};
+
+void test_success()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+
+   // Now send the request
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*1\r\n"
+         "%2\r\n"
+            "$2\r\nip\r\n$8\r\nhost.one\r\n$4\r\nport\r\n$5\r\n26380\r\n",
+      // clang-format on
+   });
+
+   // We received a valid request, so we're done
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // The Sentinel list is updated
+   const address expected_sentinels[] = {
+      {"host1",    "1000" },
+      {"host.one", "26380"},
+      {"host4",    "4000" },
+   };
+   BOOST_TEST_ALL_EQ(
+      fix.st.sentinels.begin(),
+      fix.st.sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+
+   // Logs
+   fix.check_log({
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000 resolved the server address to test.host:6380"},
+   });
+}
+
+void test_success_replica()
+{
+   // Setup. Seed the engine so that it returns index 1
+   fixture fix;
+   fix.st.cfg.sentinel.server_role = role::replica;
+   fix.st.eng.get().seed(static_cast<std::uint_fast32_t>(183984887232u));
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+
+   // Now send the request
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*3\r\n"
+         "%2\r\n"
+            "$2\r\nip\r\n$11\r\nreplica.one\r\n$4\r\nport\r\n$4\r\n6379\r\n"
+         "%2\r\n"
+            "$2\r\nip\r\n$11\r\nreplica.two\r\n$4\r\nport\r\n$4\r\n6379\r\n"
+         "%2\r\n"
+            "$2\r\nip\r\n$11\r\nreplica.thr\r\n$4\r\nport\r\n$4\r\n6379\r\n",
+      "*0\r\n"
+      // clang-format on
+   });
+
+   // We received a valid request, so we're done
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The address of one of the replicas is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"replica.two", "6379"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of a replica of master 'mymaster' using Sentinel" },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                                       },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                                       },
+      {logger::level::info,  "Sentinel at host1:1000 resolved the server address to replica.two:6379"         },
+      // clang-format on
+   });
+}
+
+// The first Sentinel fails connection, but subsequent ones succeed
+void test_one_connect_error()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+
+   // This errors, so we connect to the 2nd sentinel
+   act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+
+   // Now send the request
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+
+   // We received a valid request, so we're done
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: connection establishment error: Connect timeout. [boost.redis:18]" },
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to test.host:6380"},
+      // clang-format on
+   });
+}
+
+// The first Sentinel fails while executing the request, but subsequent ones succeed
+void test_one_request_network_error()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate, connect to the 1st Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+
+   // It fails, so we connect to the 2nd sentinel. This one succeeds
+   act = fix.fsm.resume(fix.st, error::write_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: error while executing request: Timeout while writing data to the server. [boost.redis:27]"},
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to test.host:6380"},
+      // clang-format on
+   });
+}
+
+// The first Sentinel responds with an invalid message, but subsequent ones succeed
+void test_one_request_parse_error()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate, connect to the 1st Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "+OK\r\n",
+      "+OK\r\n",
+   });
+
+   // This fails parsing, so we connect to the 2nd sentinel. This one succeeds
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: error parsing response (maybe forgot to upgrade to RESP3?): "
+                             "Expects a RESP3 array, but got a different data type. [boost.redis:32]"},
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to test.host:6380"},
+      // clang-format on
+   });
+}
+
+// The first Sentinel responds with an error (e.g. failed auth), but subsequent ones succeed
+void test_one_request_error_node()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate, connect to the 1st Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "-ERR needs authentication\r\n",
+      "-ERR needs authentication\r\n",
+   });
+
+   // This fails, so we connect to the 2nd sentinel. This one succeeds
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: responded with an error: ERR needs authentication"},
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to test.host:6380"},
+      // clang-format on
+   });
+}
+
+// The first Sentinel doesn't know about the master, but others do
+void test_one_master_unknown()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate, connect to the 1st Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "_\r\n",
+      "-ERR unknown master\r\n",
+   });
+
+   // It doesn't know about our master, so we connect to the 2nd sentinel.
+   // This one succeeds
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The master's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"test.host", "6380"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: doesn't know about the configured master"    },
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to test.host:6380"},
+      // clang-format on
+   });
+}
+
+// The first Sentinel thinks there are no replicas (stale data?), but others do
+void test_one_no_replicas()
+{
+   // Setup
+   fixture fix;
+   fix.st.cfg.sentinel.server_role = role::replica;
+
+   // Initiate, connect to the 1st Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+      "*0\r\n",
+   });
+
+   // This errors, so we connect to the 2nd sentinel. This one succeeds
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      // clang-format off
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*1\r\n"
+         "%2\r\n"
+            "$2\r\nip\r\n$11\r\nreplica.one\r\n$4\r\nport\r\n$4\r\n6379\r\n",
+      "*0\r\n",
+      // clang-format on
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code());
+
+   // The replica's address is stored
+   BOOST_TEST_EQ(fix.st.cfg.addr, (address{"replica.one", "6379"}));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of a replica of master 'mymaster' using Sentinel"   },
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: the configured master has no replicas"       },
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::debug, "Executing Sentinel request at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000 resolved the server address to replica.one:6379"},
+      // clang-format on
+   });
+}
+
+// If no Sentinel is available, the operation fails. A comprehensive error is logged.
+void test_error()
+{
+   // Setup
+   fixture fix;
+
+   // 1st Sentinel doesn't know about the master
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "_\r\n",
+      "-ERR unknown master\r\n",
+   });
+
+   // Move to the 2nd Sentinel, which fails to connect
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host2", "2000"}));
+
+   // Move to the 3rd Sentinel, which has authentication misconfigured
+   act = fix.fsm.resume(fix.st, error::connect_timeout, cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host3", "3000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "-ERR unauthorized\r\n",
+      "-ERR unauthorized\r\n",
+   });
+
+   // Sentinel list exhausted
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::sentinel_resolve_failed));
+
+   // The Sentinel list is not updated
+   BOOST_TEST_EQ(fix.st.sentinels.size(), 3u);
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"   },
+
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: doesn't know about the configured master"    },
+
+      {logger::level::debug, "Trying to contact Sentinel at host2:2000"                            },
+      {logger::level::info,  "Sentinel at host2:2000: connection establishment error: Connect timeout. [boost.redis:18]" },
+
+      {logger::level::debug, "Trying to contact Sentinel at host3:3000"                            },
+      {logger::level::debug, "Executing Sentinel request at host3:3000"                            },
+      {logger::level::info,  "Sentinel at host3:3000: responded with an error: ERR unauthorized"},
+
+      {logger::level::err,  "Failed to resolve the address of master 'mymaster'. Tried the following Sentinels:"
+                            "\n  Sentinel at host1:1000: doesn't know about the configured master"
+                            "\n  Sentinel at host2:2000: connection establishment error: Connect timeout. [boost.redis:18]"
+                            "\n  Sentinel at host3:3000: responded with an error: ERR unauthorized"},
+      // clang-format on
+   });
+}
+
+// The replica error text is slightly different
+void test_error_replica()
+{
+   // Setup
+   fixture fix;
+   fix.st.sentinels = {
+      {"host1", "1000"}
+   };
+   fix.st.cfg.sentinel.server_role = role::replica;
+
+   // Initiate, connect to the only Sentinel, and send the request
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   fix.st.sentinel_resp_nodes = nodes_from_resp3({
+      "*2\r\n$9\r\ntest.host\r\n$4\r\n6380\r\n",
+      "*0\r\n",
+      "*0\r\n",
+   });
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, error_code(error::sentinel_resolve_failed));
+
+   // Logs
+   fix.check_log({
+      // clang-format off
+      {logger::level::info,  "Trying to resolve the address of a replica of master 'mymaster' using Sentinel"   },
+
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                            },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                            },
+      {logger::level::info,  "Sentinel at host1:1000: the configured master has no replicas"    },
+
+      {logger::level::err,  "Failed to resolve the address of a replica of master 'mymaster'. Tried the following Sentinels:"
+                            "\n  Sentinel at host1:1000: the configured master has no replicas"},
+      // clang-format on
+   });
+}
+
+// Cancellations
+void test_cancel_connect()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+
+   // Cancellation
+   act = fix.fsm.resume(fix.st, asio::error::operation_aborted, cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Logs
+   fix.check_log({
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"},
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                         },
+      {logger::level::debug, "Sentinel resolve: cancelled (1)"                                  },
+   });
+}
+
+void test_cancel_connect_edge()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+
+   // Cancellation (without error code)
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Logs
+   fix.check_log({
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"},
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                         },
+      {logger::level::debug, "Sentinel resolve: cancelled (1)"                                  },
+   });
+}
+
+void test_cancel_request()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   act = fix.fsm.resume(fix.st, asio::error::operation_aborted, cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Logs
+   fix.check_log({
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"},
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                         },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                         },
+      {logger::level::debug, "Sentinel resolve: cancelled (2)"                                  },
+   });
+}
+
+void test_cancel_request_edge()
+{
+   // Setup
+   fixture fix;
+
+   // Initiate. We should connect to the 1st sentinel
+   auto act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, (address{"host1", "1000"}));
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::none);
+   BOOST_TEST_EQ(act, sentinel_action::request());
+   act = fix.fsm.resume(fix.st, error_code(), cancellation_type_t::terminal);
+   BOOST_TEST_EQ(act, error_code(asio::error::operation_aborted));
+
+   // Logs
+   fix.check_log({
+      {logger::level::info,  "Trying to resolve the address of master 'mymaster' using Sentinel"},
+      {logger::level::debug, "Trying to contact Sentinel at host1:1000"                         },
+      {logger::level::debug, "Executing Sentinel request at host1:1000"                         },
+      {logger::level::debug, "Sentinel resolve: cancelled (2)"                                  },
+   });
+}
+
+}  // namespace
+
+int main()
+{
+   test_success();
+   test_success_replica();
+
+   test_one_connect_error();
+   test_one_request_network_error();
+   test_one_request_parse_error();
+   test_one_request_error_node();
+   test_one_master_unknown();
+   test_one_no_replicas();
+
+   test_error();
+   test_error_replica();
+
+   test_cancel_connect();
+   test_cancel_connect_edge();
+   test_cancel_request();
+   test_cancel_request_edge();
+
+   return boost::report_errors();
+}

test/test_serialization.cpp

@@ -0,0 +1,193 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/request.hpp>
+#include <boost/redis/resp3/serialization.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+using boost::redis::request;
+
+namespace other {
+
+struct my_struct {
+   int value;
+};
+
+void boost_redis_to_bulk(std::string& to, my_struct value)
+{
+   boost::redis::resp3::boost_redis_to_bulk(to, value.value);
+}
+
+}  // namespace other
+
+namespace {
+
+// --- Strings ---
+void test_string_view()
+{
+   request req;
+   req.push("GET", std::string_view("key"));
+   BOOST_TEST_EQ(req.payload(), "*2\r\n$3\r\nGET\r\n$3\r\nkey\r\n");
+}
+
+void test_string()
+{
+   std::string s{"k1"};
+   const std::string s2{"k2"};
+   request req;
+   req.push("GET", s, s2, std::string("k3"));
+   BOOST_TEST_EQ(req.payload(), "*4\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\nk2\r\n$2\r\nk3\r\n");
+}
+
+void test_c_string()
+{
+   request req;
+   req.push("GET", "k1", static_cast<const char*>("k2"));
+   BOOST_TEST_EQ(req.payload(), "*3\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\nk2\r\n");
+}
+
+void test_string_empty()
+{
+   request req;
+   req.push("GET", std::string_view{});
+   BOOST_TEST_EQ(req.payload(), "*2\r\n$3\r\nGET\r\n$0\r\n\r\n");
+}
+
+// --- Integers ---
+void test_signed_ints()
+{
+   request req;
+   req.push("GET", static_cast<signed char>(20), static_cast<short>(-42), -1, 80l, 200ll);
+   BOOST_TEST_EQ(
+      req.payload(),
+      "*6\r\n$3\r\nGET\r\n$2\r\n20\r\n$3\r\n-42\r\n$2\r\n-1\r\n$2\r\n80\r\n$3\r\n200\r\n");
+}
+
+void test_unsigned_ints()
+{
+   request req;
+   req.push(
+      "GET",
+      static_cast<unsigned char>(20),
+      static_cast<unsigned short>(42),
+      50u,
+      80ul,
+      200ull);
+   BOOST_TEST_EQ(
+      req.payload(),
+      "*6\r\n$3\r\nGET\r\n$2\r\n20\r\n$2\r\n42\r\n$2\r\n50\r\n$2\r\n80\r\n$3\r\n200\r\n");
+}
+
+// We don't overflow for big ints
+void test_signed_ints_minmax()
+{
+   using lims = std::numeric_limits<std::int64_t>;
+   request req;
+   req.push("GET", (lims::min)(), (lims::max)());
+   BOOST_TEST_EQ(
+      req.payload(),
+      "*3\r\n$3\r\nGET\r\n$20\r\n-9223372036854775808\r\n$19\r\n9223372036854775807\r\n");
+}
+
+void test_unsigned_ints_max()
+{
+   request req;
+   req.push("GET", (std::numeric_limits<std::uint64_t>::max)());
+   BOOST_TEST_EQ(req.payload(), "*2\r\n$3\r\nGET\r\n$20\r\n18446744073709551615\r\n");
+}
+
+// Custom type
+void test_custom()
+{
+   request req;
+   req.push("GET", other::my_struct{42});
+   BOOST_TEST_EQ(req.payload(), "*2\r\n$3\r\nGET\r\n$2\r\n42\r\n");
+}
+
+// --- Pairs and tuples (only supported in the range versions) ---
+// Nested structures are not supported (compile time error)
+void test_pair()
+{
+   std::vector<std::pair<std::string_view, int>> vec{
+      {"k1", 42}
+   };
+   request req;
+   req.push_range("GET", vec);
+   BOOST_TEST_EQ(req.payload(), "*3\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\n42\r\n");
+}
+
+void test_pair_custom()
+{
+   std::vector<std::pair<std::string_view, other::my_struct>> vec{
+      {"k1", {42}}
+   };
+   request req;
+   req.push_range("GET", vec);
+   BOOST_TEST_EQ(req.payload(), "*3\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\n42\r\n");
+}
+
+void test_tuple()
+{
+   std::vector<std::tuple<std::string_view, int, unsigned char>> vec{
+      {"k1", 42, 1}
+   };
+   request req;
+   req.push_range("GET", vec);
+   BOOST_TEST_EQ(req.payload(), "*4\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\n42\r\n$1\r\n1\r\n");
+}
+
+void test_tuple_custom()
+{
+   std::vector<std::tuple<std::string_view, other::my_struct>> vec{
+      {"k1", {42}}
+   };
+   request req;
+   req.push_range("GET", vec);
+   BOOST_TEST_EQ(req.payload(), "*3\r\n$3\r\nGET\r\n$2\r\nk1\r\n$2\r\n42\r\n");
+}
+
+void test_tuple_empty()
+{
+   std::vector<std::tuple<>> vec{{}};
+   request req;
+   req.push_range("GET", vec);
+   BOOST_TEST_EQ(req.payload(), "*1\r\n$3\r\nGET\r\n");
+}
+
+}  // namespace
+
+int main()
+{
+   test_string_view();
+   test_string();
+   test_c_string();
+   test_string_empty();
+
+   test_signed_ints();
+   test_unsigned_ints();
+   test_signed_ints_minmax();
+   test_unsigned_ints_max();
+
+   test_custom();
+
+   test_pair();
+   test_pair_custom();
+   test_tuple();
+   test_tuple_custom();
+   test_tuple_empty();
+
+   return boost::report_errors();
+}

test/test_setup_adapter.cpp

@@ -0,0 +1,349 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/detail/connection_state.hpp>
+#include <boost/redis/impl/setup_request_utils.hpp>
+#include <boost/redis/resp3/parser.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/result.hpp>
+
+#include <string_view>
+
+using namespace boost::redis;
+using detail::setup_adapter;
+using detail::connection_state;
+using detail::compose_setup_request;
+using boost::system::error_code;
+
+namespace {
+
+void test_success()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.push("SELECT", 2);
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the SELECT command
+   p.reset();
+   done = resp3::parse(p, "+OK\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+void test_simple_error()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO contains an error
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "-ERR unauthorized\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::resp3_hello);
+   BOOST_TEST_EQ(st.diagnostic, "ERR unauthorized");
+}
+
+void test_blob_error()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.push("SELECT", 1);
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to select contains an error
+   p.reset();
+   done = resp3::parse(p, "!3\r\nBad\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::resp3_hello);
+   BOOST_TEST_EQ(st.diagnostic, "Bad");
+}
+
+// A NULL is not an error
+void test_null()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "_\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+// Sentinel adds a ROLE command and checks its output.
+// These are real wire values.
+constexpr std::string_view role_master_response =
+   "*3\r\n$6\r\nmaster\r\n:567942\r\n*2\r\n"
+   "*3\r\n$9\r\nlocalhost\r\n$4\r\n6381\r\n$6\r\n567809\r\n*3\r\n$9\r\nlocalhost\r\n"
+   "$4\r\n6382\r\n$6\r\n567809\r\n";
+constexpr std::string_view role_replica_response =
+   "*5\r\n$5\r\nslave\r\n$9\r\nlocalhost\r\n:6380\r\n$9\r\nconnected\r\n:617355\r\n";
+
+void test_sentinel_master()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.push("SELECT", 2);
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the SELECT command
+   p.reset();
+   done = resp3::parse(p, "+OK\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the ROLE command
+   p.reset();
+   done = resp3::parse(p, role_master_response, adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+void test_sentinel_replica()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   st.cfg.sentinel.server_role = role::replica;
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the ROLE command
+   p.reset();
+   done = resp3::parse(p, role_replica_response, adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+// If the role is not the one expected, a role failed error is issued
+void test_sentinel_role_check_failed_master()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the ROLE command
+   p.reset();
+   done = resp3::parse(p, role_replica_response, adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::role_check_failed);
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+void test_sentinel_role_check_failed_replica()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   st.cfg.sentinel.server_role = role::replica;
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to HELLO
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "%1\r\n$6\r\nserver\r\n$5\r\nredis\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error_code());
+
+   // Response to the ROLE command
+   p.reset();
+   done = resp3::parse(p, role_master_response, adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::role_check_failed);
+
+   // No diagnostic
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+// If the role command errors or has an unexpected format, we fail
+void test_sentinel_role_error_node()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.clear();
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to ROLE
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "-ERR unauthorized\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::resp3_hello);
+   BOOST_TEST_EQ(st.diagnostic, "ERR unauthorized");
+}
+
+void test_sentinel_role_not_array()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.clear();
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to ROLE
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "+OK\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::invalid_data_type);
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+void test_sentinel_role_empty_array()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.clear();
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to ROLE
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "*0\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::incompatible_size);
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+void test_sentinel_role_first_element_not_string()
+{
+   // Setup
+   connection_state st;
+   st.cfg.use_setup = true;
+   st.cfg.setup.clear();
+   st.cfg.sentinel.addresses = {
+      {"localhost", "26379"}
+   };
+   compose_setup_request(st.cfg);
+   setup_adapter adapter{st};
+
+   // Response to ROLE
+   resp3::parser p;
+   error_code ec;
+   bool done = resp3::parse(p, "*1\r\n:2000\r\n", adapter, ec);
+   BOOST_TEST(done);
+   BOOST_TEST_EQ(ec, error::invalid_data_type);
+   BOOST_TEST_EQ(st.diagnostic, "");
+}
+
+}  // namespace
+
+int main()
+{
+   test_success();
+   test_simple_error();
+   test_blob_error();
+   test_null();
+
+   test_sentinel_master();
+   test_sentinel_replica();
+   test_sentinel_role_check_failed_master();
+   test_sentinel_role_check_failed_replica();
+   test_sentinel_role_error_node();
+   test_sentinel_role_not_array();
+   test_sentinel_role_empty_array();
+   test_sentinel_role_first_element_not_string();
+
+   return boost::report_errors();
+}

test/test_unix_sockets.cpp

@@ -131,7 +131,7 @@ void test_switch_between_transports()
    // Create configurations for TLS and UNIX connections
    auto tcp_tls_cfg = make_test_config();
    tcp_tls_cfg.use_ssl = true;
-   tcp_tls_cfg.addr.port = "6380";
+   tcp_tls_cfg.addr.port = "16380";
    auto unix_cfg = make_test_config();
    unix_cfg.unix_socket = unix_socket_path;
 
@@ -194,7 +194,7 @@ void test_error_unix_tls()
    connection conn{ioc};
    auto cfg = make_test_config();
    cfg.use_ssl = true;
-   cfg.addr.port = "6380";
+   cfg.addr.port = "16380";
    cfg.unix_socket = unix_socket_path;
    bool finished = false;
 

test/test_update_sentinel_list.cpp

@@ -0,0 +1,212 @@
+//
+// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
+// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/impl/sentinel_utils.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <vector>
+
+using namespace boost::redis;
+using detail::update_sentinel_list;
+using boost::system::error_code;
+
+// Operators
+namespace boost::redis {
+
+std::ostream& operator<<(std::ostream& os, const address& addr)
+{
+   return os << "address{ .host=" << addr.host << ", .port=" << addr.port << " }";
+}
+
+}  // namespace boost::redis
+
+namespace {
+
+// The only Sentinel resolved the address successfully, and there's no newly discovered Sentinels
+void test_single_sentinel()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"}
+   };
+   std::vector<address> sentinels{initial_sentinels};
+
+   update_sentinel_list(sentinels, 0u, {}, initial_sentinels);
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      initial_sentinels.begin(),
+      initial_sentinels.end());
+}
+
+// Some new Sentinels were discovered using SENTINEL SENTINELS
+void test_new_sentinels()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"}
+   };
+   std::vector<address> sentinels{initial_sentinels};
+   const address new_sentinels[]{
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   update_sentinel_list(sentinels, 0u, new_sentinels, initial_sentinels);
+
+   const address expected_sentinels[]{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+}
+
+// Some of the new Sentinels are already in the list
+void test_new_sentinels_known()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"},
+      {"host2", "2000"},
+   };
+   std::vector<address> sentinels{initial_sentinels};
+   const address new_sentinels[]{
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   update_sentinel_list(sentinels, 0u, new_sentinels, initial_sentinels);
+
+   const address expected_sentinels[]{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+}
+
+// The Sentinel that succeeded should be placed first
+void test_success_sentinel_not_first()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+   std::vector<address> sentinels{initial_sentinels};
+   const address new_sentinels[]{
+      {"host1", "1000"},
+      {"host2", "2000"},
+   };
+
+   update_sentinel_list(sentinels, 2u, new_sentinels, initial_sentinels);
+
+   const address expected_sentinels[]{
+      {"host3", "3000"},
+      {"host1", "1000"},
+      {"host2", "2000"},
+   };
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+}
+
+// If a discovered Sentinel is not returned in subsequent iterations, it's removed from the list
+void test_new_sentinel_removed()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"},
+   };
+   std::vector<address> sentinels{
+      {"host1", "1000"},
+      {"host4", "4000"},
+   };
+   const address new_sentinels[]{
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   update_sentinel_list(sentinels, 0u, new_sentinels, initial_sentinels);
+
+   const address expected_sentinels[]{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+}
+
+// Bootstrap Sentinels are never removed
+void test_bootstrap_sentinel_removed()
+{
+   const std::vector<address> initial_sentinels{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+   };
+   std::vector<address> sentinels{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host3", "3000"},
+      {"host4", "4000"},
+      {"host5", "5000"},
+   };
+   const address new_sentinels[]{
+      {"host2", "2000"},
+      {"host4", "4000"},
+   };
+
+   update_sentinel_list(sentinels, 0u, new_sentinels, initial_sentinels);
+
+   const address expected_sentinels[]{
+      {"host1", "1000"},
+      {"host2", "2000"},
+      {"host4", "4000"},
+      {"host3", "3000"}, // bootstrap Sentinels placed last
+   };
+
+   BOOST_TEST_ALL_EQ(
+      sentinels.begin(),
+      sentinels.end(),
+      std::begin(expected_sentinels),
+      std::end(expected_sentinels));
+}
+
+}  // namespace
+
+int main()
+{
+   test_single_sentinel();
+   test_new_sentinels();
+   test_new_sentinels_known();
+   test_success_sentinel_not_first();
+   test_new_sentinel_removed();
+   test_bootstrap_sentinel_removed();
+
+   return boost::report_errors();
+}

tools/docker-compose.yml

@@ -1,19 +1,140 @@
 services:
-  redis:
+  redis-master:
+    container_name: redis-master
     image: ${SERVER_IMAGE}
-    entrypoint: "/docker/entrypoint.sh"
+    network_mode: host
+    command: >
+      sh -c 'chmod 777 /tmp/redis-socks &&
+             redis-server \
+              --replica-announce-ip localhost \
+              --port 6379 \
+              --tls-port 16379 \
+              --tls-cert-file /docker/tls/server.crt \
+              --tls-key-file /docker/tls/server.key \
+              --tls-ca-cert-file /docker/tls/ca.crt \
+              --tls-auth-clients no \
+              --unixsocket /tmp/redis-socks/redis.sock \
+              --unixsocketperm 777'
     volumes:
       - ./docker:/docker
       - /tmp/redis-socks:/tmp/redis-socks
-    ports:
-      - 6379:6379
-      - 6380:6380
+
+  redis-replica-1:
+    container_name: redis-replica-1
+    image: ${SERVER_IMAGE}
+    network_mode: host
+    command:
+      [
+        "redis-server",
+        "--replica-announce-ip", "localhost",
+        "--replicaof", "localhost", "6379",
+        "--port", "6380",
+        "--tls-port", "16380",
+        "--tls-cert-file", "/docker/tls/server.crt",
+        "--tls-key-file", "/docker/tls/server.key",
+        "--tls-ca-cert-file", "/docker/tls/ca.crt",
+        "--tls-auth-clients", "no",
+      ]
+    volumes:
+      - ./docker:/docker
+
+
+  redis-replica-2:
+    container_name: redis-replica-2
+    image: ${SERVER_IMAGE}
+    network_mode: host
+    command:
+      [
+        "redis-server",
+        "--replica-announce-ip", "localhost",
+        "--replicaof", "localhost", "6379",
+        "--port", "6381",
+        "--tls-port", "16381",
+        "--tls-cert-file", "/docker/tls/server.crt",
+        "--tls-key-file", "/docker/tls/server.key",
+        "--tls-ca-cert-file", "/docker/tls/ca.crt",
+        "--tls-auth-clients", "no",
+      ]
+    volumes:
+      - ./docker:/docker
+
+
+  sentinel-1:
+    container_name: sentinel-1
+    image: ${SERVER_IMAGE}
+    network_mode: host
+    command: >
+      sh -c 'cat << EOF > /etc/sentinel.conf && redis-sentinel /etc/sentinel.conf
+        port 26379
+        tls-port 36379
+        tls-cert-file /docker/tls/server.crt
+        tls-key-file /docker/tls/server.key
+        tls-ca-cert-file /docker/tls/ca.crt
+        tls-auth-clients no
+        sentinel resolve-hostnames yes
+        sentinel announce-hostnames yes
+        sentinel announce-ip localhost
+        sentinel monitor mymaster localhost 6379 2
+        sentinel down-after-milliseconds mymaster 10000
+        sentinel failover-timeout mymaster 10000
+        sentinel parallel-syncs mymaster 1
+      EOF'
+    volumes:
+      - ./docker:/docker
+
+
+  sentinel-2:
+    container_name: sentinel-2
+    image: ${SERVER_IMAGE}
+    network_mode: host
+    command: >
+      sh -c 'cat << EOF > /etc/sentinel.conf && redis-sentinel /etc/sentinel.conf
+        port 26380
+        tls-port 36380
+        tls-cert-file /docker/tls/server.crt
+        tls-key-file /docker/tls/server.key
+        tls-ca-cert-file /docker/tls/ca.crt
+        tls-auth-clients no
+        sentinel resolve-hostnames yes
+        sentinel announce-hostnames yes
+        sentinel announce-ip localhost
+        sentinel monitor mymaster localhost 6379 2
+        sentinel down-after-milliseconds mymaster 10000
+        sentinel failover-timeout mymaster 10000
+        sentinel parallel-syncs mymaster 1
+      EOF'
+    volumes:
+      - ./docker:/docker
+
+  sentinel-3:
+    container_name: sentinel-3
+    image: ${SERVER_IMAGE}
+    network_mode: host
+    command: >
+      sh -c 'cat << EOF > /etc/sentinel.conf && redis-sentinel /etc/sentinel.conf
+        port 26381
+        tls-port 36381
+        tls-cert-file /docker/tls/server.crt
+        tls-key-file /docker/tls/server.key
+        tls-ca-cert-file /docker/tls/ca.crt
+        tls-auth-clients no
+        sentinel resolve-hostnames yes
+        sentinel announce-hostnames yes
+        sentinel announce-ip localhost
+        sentinel monitor mymaster localhost 6379 2
+        sentinel down-after-milliseconds mymaster 10000
+        sentinel failover-timeout mymaster 10000
+        sentinel parallel-syncs mymaster 1
+      EOF'
+    volumes:
+      - ./docker:/docker
+
+
   builder:
-    image: ${BUILDER_IMAGE}
     container_name: builder
+    image: ${BUILDER_IMAGE}
+    network_mode: host
     tty: true
-    environment:
-      - BOOST_REDIS_TEST_SERVER=redis
     volumes:
       - ../:/boost-redis
       - /tmp/redis-socks:/tmp/redis-socks

tools/docker/entrypoint.sh

@@ -1,16 +0,0 @@
-#!/bin/sh
-# The Redis container entrypoint. Runs the server with the required
-# flags and makes the socket accessible
-
-set -e
-
-chmod 777 /tmp/redis-socks
-
-redis-server \
-    --tls-port 6380 \
-    --tls-cert-file /docker/tls/server.crt \
-    --tls-key-file /docker/tls/server.key \
-    --tls-ca-cert-file /docker/tls/ca.crt \
-    --tls-auth-clients no \
-    --unixsocket /tmp/redis-socks/redis.sock \
-    --unixsocketperm 777