Uses system::result to implement per request error handling.

Author: mzimbres

CMakeLists.txt

@@ -275,6 +275,15 @@ if (MSVC)
     target_compile_definitions(test_conn_exec_cancel PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
+add_executable(test_conn_exec_error tests/conn_exec_error.cpp)
+target_compile_features(test_conn_exec_error PUBLIC cxx_std_17)
+target_link_libraries(test_conn_exec_error common)
+add_test(test_conn_exec_error test_conn_exec_error)
+if (MSVC)
+    target_compile_options(test_conn_exec_error PRIVATE /bigobj)
+    target_compile_definitions(test_conn_exec_error PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 add_executable(test_conn_echo_stress tests/conn_echo_stress.cpp)
 target_compile_features(test_conn_echo_stress PUBLIC cxx_std_20)
 target_link_libraries(test_conn_echo_stress common)

README.md

@@ -870,6 +870,10 @@ Acknowledgement to people that helped shape Boost.Redis
 * Adds new typedef `boost::redis::generic_response` that should be used instead of `std::vector<resp3::node<std::string>>`.
 * Renames `redis::ignore` to `redis::ignore_t`.
 * Changes the signature from `async_exec` to receive a `redis::response` instead of an adapter.
+* Adds `boost::redis::adapter::result` to store responses to commands
+  including possible resp3 errors without losing the error diagnostic
+  part. Basicaly instead of accessing values as `std::get<N>(resp)`
+  users have to type `std::get<N>(resp).value()`
 
 ### v1.4.0-1
 

examples/cpp17_intro.cpp

@@ -14,6 +14,7 @@ namespace redis = boost::redis;
 using redis::operation;
 using redis::request;
 using redis::response;
+using redis::ignore_t;
 
 void log(boost::system::error_code const& ec, char const* prefix)
 {
@@ -38,7 +39,7 @@ auto main(int argc, char * argv[]) -> int
       req.push("QUIT");
 
       // The response.
-      response<redis::ignore_t, std::string, redis::ignore_t> resp;
+      response<ignore_t, std::string, ignore_t> resp;
 
       net::io_context ioc;
 
@@ -64,7 +65,7 @@ auto main(int argc, char * argv[]) -> int
             return log(ec, "on_exec: ");
          }
 
-         std::cout << "PING: " << std::get<1>(resp) << std::endl;
+         std::cout << "PING: " << std::get<1>(resp).value() << std::endl;
       };
 
       // Connect callback.

examples/cpp17_intro_sync.cpp

@@ -15,10 +15,10 @@
 #include <boost/redis/src.hpp>
 
 namespace net = boost::asio;
-namespace redis = boost::redis;
-using connection = redis::connection;
+using connection = boost::redis::connection;
 using boost::redis::request;
 using boost::redis::response;
+using boost::redis::ignore_t;
 
 template <class Response>
 auto exec(std::shared_ptr<connection> conn, request const& req, Response& resp)
@@ -66,12 +66,12 @@ auto main(int argc, char * argv[]) -> int
       req.push("PING");
       req.push("QUIT");
 
-      response<boost::redis::ignore_t, std::string, boost::redis::ignore_t> resp;
+      response<ignore_t, std::string, ignore_t> resp;
 
       // Executes commands synchronously.
       exec(conn, req, resp);
 
-      std::cout << "Response: " << std::get<1>(resp) << std::endl;
+      std::cout << "Response: " << std::get<1>(resp).value() << std::endl;
 
       t.join();
    } catch (std::exception const& e) {

examples/cpp17_low_level_sync.cpp

@@ -12,10 +12,10 @@
 #include <boost/redis/src.hpp>
 
 namespace net = boost::asio;
-namespace redis = boost::redis;
-namespace resp3 = redis::resp3;
-using redis::adapter::adapt2;
+namespace resp3 = boost::redis::resp3;
+using boost::redis::adapter::adapt2;
 using boost::redis::request;
+using boost::redis::adapter::result;
 
 auto main(int argc, char * argv[]) -> int
 {
@@ -41,16 +41,16 @@ auto main(int argc, char * argv[]) -> int
       req.push("QUIT");
       resp3::write(socket, req);
 
-      // Responses
-      std::string buffer, resp;
+      std::string buffer;
+      result<std::string> resp;
 
       // Reads the responses to all commands in the request.
       auto dbuffer = net::dynamic_buffer(buffer);
       resp3::read(socket, dbuffer);
       resp3::read(socket, dbuffer, adapt2(resp));
       resp3::read(socket, dbuffer);
 
-      std::cout << "Ping: " << resp << std::endl;
+      std::cout << "Ping: " << resp.value() << std::endl;
 
    } catch (std::exception const& e) {
       std::cerr << e.what() << std::endl;

examples/cpp20_chat_room.cpp

@@ -29,8 +29,8 @@ auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    for (generic_response resp;;) {
       co_await conn->async_receive(resp);
-      std::cout << resp.at(1).value << " " << resp.at(2).value << " " << resp.at(3).value << std::endl;
-      resp.clear();
+      std::cout << resp.value().at(1).value << " " << resp.value().at(2).value << " " << resp.value().at(3).value << std::endl;
+      resp.value().clear();
    }
 }
 

examples/cpp20_containers.cpp

@@ -18,6 +18,7 @@ namespace redis = boost::redis;
 using namespace net::experimental::awaitable_operators;
 using boost::redis::request;
 using boost::redis::response;
+using boost::redis::ignore_t;
 
 void print(std::map<std::string, std::string> const& cont)
 {
@@ -62,12 +63,12 @@ auto hgetall(std::shared_ptr<connection> conn) -> net::awaitable<void>
    req.push("HGETALL", "hset-key");
 
    // Responses as tuple elements.
-   response<redis::ignore_t, std::map<std::string, std::string>> resp;
+   response<ignore_t, std::map<std::string, std::string>> resp;
 
    // Executes the request and reads the response.
    co_await conn->async_exec(req, resp);
 
-   print(std::get<1>(resp));
+   print(std::get<1>(resp).value());
 }
 
 // Retrieves in a transaction.
@@ -81,17 +82,17 @@ auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
    req.push("EXEC");
 
    response<
-      redis::ignore_t, // hello
-      redis::ignore_t, // multi
-      redis::ignore_t, // lrange
-      redis::ignore_t, // hgetall
+      ignore_t, // hello
+      ignore_t, // multi
+      ignore_t, // lrange
+      ignore_t, // hgetall
       response<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>> // exec
    > resp;
 
    co_await conn->async_exec(req, resp);
 
-   print(std::get<0>(std::get<4>(resp)).value());
-   print(std::get<1>(std::get<4>(resp)).value());
+   print(std::get<0>(std::get<4>(resp).value()).value().value());
+   print(std::get<1>(std::get<4>(resp).value()).value().value());
 }
 
 auto quit(std::shared_ptr<connection> conn) -> net::awaitable<void>

examples/cpp20_echo_server.cpp

@@ -27,8 +27,8 @@ auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) ->
       auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
       req.push("PING", buffer);
       co_await conn->async_exec(req, resp);
-      co_await net::async_write(socket, net::buffer(std::get<0>(resp)));
-      std::get<0>(resp).clear();
+      co_await net::async_write(socket, net::buffer(std::get<0>(resp).value()));
+      std::get<0>(resp).value().clear();
       req.clear();
       buffer.erase(0, n);
    }

examples/cpp20_intro.cpp

@@ -36,7 +36,7 @@ auto ping(std::shared_ptr<connection> conn) -> net::awaitable<void>
    response<std::string> resp;
    co_await conn->async_exec(req, resp);
 
-   std::cout << "PING: " << std::get<0>(resp) << std::endl;
+   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
 }
 
 auto quit(std::shared_ptr<connection> conn) -> net::awaitable<void>

examples/cpp20_intro_awaitable_ops.cpp

@@ -14,22 +14,27 @@ namespace net = boost::asio;
 using namespace net::experimental::awaitable_operators;
 using boost::redis::request;
 using boost::redis::response;
+using boost::redis::ignore_t;
 
 // Called from the main function (see main.cpp)
 auto co_main(std::string host, std::string port) -> net::awaitable<void>
 {
-   request req;
-   req.push("HELLO", 3);
-   req.push("PING", "Hello world");
-   req.push("QUIT");
+   try {
+      request req;
+      req.push("HELLO", 3);
+      req.push("PING", "Hello world");
+      req.push("QUIT");
 
-   response<boost::redis::ignore_t, std::string, boost::redis::ignore_t> resp;
+      response<ignore_t, std::string, ignore_t> resp;
 
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   co_await connect(conn, host, port);
-   co_await (conn->async_run() || conn->async_exec(req, resp));
+      auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+      co_await connect(conn, host, port);
+      co_await (conn->async_run() || conn->async_exec(req, resp));
 
-   std::cout << "PING: " << std::get<1>(resp) << std::endl;
+      std::cout << "PING: " << std::get<1>(resp).value() << std::endl;
+   } catch (std::exception const& e) {
+      std::cout << e.what() << std::endl;
+   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_CO_AWAIT)