Adds example that does not user awaitable ops.

Author: mzimbres

CMakeLists.txt

@@ -82,6 +82,15 @@ if (MSVC)
     target_compile_definitions(cpp20_intro PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
+add_executable(cpp20_intro_awaitable_ops examples/cpp20_intro_awaitable_ops.cpp)
+target_link_libraries(cpp20_intro_awaitable_ops common)
+target_compile_features(cpp20_intro_awaitable_ops PUBLIC cxx_std_20)
+add_test(cpp20_intro_awaitable_ops cpp20_intro_awaitable_ops)
+if (MSVC)
+    target_compile_options(cpp20_intro_awaitable_ops PRIVATE /bigobj)
+    target_compile_definitions(cpp20_intro_awaitable_ops PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 add_executable(cpp17_intro examples/cpp17_intro.cpp)
 target_compile_features(cpp17_intro PUBLIC cxx_std_17)
 add_test(cpp17_intro cpp17_intro)
@@ -199,6 +208,14 @@ if (MSVC)
     target_compile_definitions(test_conn_exec PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
+add_executable(test_conn_exec_retry tests/conn_exec_retry.cpp)
+target_compile_features(test_conn_exec_retry PUBLIC cxx_std_20)
+add_test(test_conn_exec_retry test_conn_exec_retry)
+if (MSVC)
+    target_compile_options(test_conn_exec_retry PRIVATE /bigobj)
+    target_compile_definitions(test_conn_exec_retry PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 add_executable(test_conn_push tests/conn_push.cpp)
 target_compile_features(test_conn_push PUBLIC cxx_std_20)
 add_test(test_conn_push test_conn_push)

README.md

@@ -15,7 +15,7 @@ the cases will be concerned with only three library entities
 
 For example, the coroutine below uses a short-lived connection to read Redis
 [hashes](https://redis.io/docs/data-types/hashes/)
-in a `std::map` (see cpp20_intro.cpp, cpp17_intro.cpp and containers.cpp)
+in a `std::map`
 
 ```cpp
 auto async_main() -> net::awaitable<void>
@@ -41,37 +41,40 @@ auto async_main() -> net::awaitable<void>
 }
 ```
 
+For different versions of this example using different styles see
+
+* cpp20_intro.cpp: Does not use awaitable operators
+* cpp20_intro_awaitable_ops.cpp: The version above.
+* cpp17_intro.cpp: Requires C++17 only.
+* cpp20_intro_tls.cpp: Communicates over TLS.
+
 The execution of `connection::async_exec` above is composed with
 `connection::async_run` with the aid of the Asio awaitable `operator ||`
 that ensures that  one operation is cancelled as soon as the other
 completes, these functions play the following roles
 
 * `connection::async_exec`: Execute commands by queuing the request
-  for writing and wait for the response sent back by Redis. It can be
-     called from multiple places in your code concurrently.
+  for writing. It will wait for the response sent back by Redis and
+     can be called from multiple places in your code concurrently.
 * `connection::async_run`: Coordinate low-level read and write
   operations. More specifically, it will hand IO control to
   `async_exec` when a response arrives, to
-  `aedis::connection::async_receive` when a server-push is received
+  `async_receive` when a server-push is received
   and will trigger writes of pending requests when a reconnection
   occurs.
 
 The role played by `async_run` can be better understood in the context
 of long-lived connections, which we will cover in the next section.
-Before that however, the reader might want to skim over the examples
+Before that however, the reader might want to skim over some further examples
 
-* cpp17_intro.cpp:  The Aedis hello-world program. Sends one command and quits the connection.
-* cpp17_intro_sync.cpp: Shows how to use the connection class synchronously.
-* cpp17_low_level_sync.cpp: Sends a ping synchronously using the low-level API.
-* cpp20_intro.cpp: Like cpp17_intro.cpp but uses awaitable operators.
-* cpp20_intro_tls.cpp: Same as intro.cpp but over TLS.
 * cpp20_containers.cpp: Shows how to send and receive STL containers and how to use transactions.
 * cpp20_serialization.cpp: Shows how to serialize types using Boost.Json.
 * cpp20_resolve_with_sentinel.cpp: Shows how to resolve a master address using sentinels.
 * cpp20_subscriber.cpp: Shows how to implement pubsub with reconnection re-subscription.
 * cpp20_echo_server.cpp: A simple TCP echo server.
 * cpp20_chat_room.cpp: A command line chat built on Redis pubsub.
 * cpp20_low_level_async.cpp: Sends a ping asynchronously using the low-level API.
+* cpp17_low_level_sync.cpp: Sends a ping synchronously using the low-level API.
 
 To avoid repetition code that is common to some examples has been
 grouped in common.hpp. The main function used in some async examples
@@ -159,7 +162,7 @@ auto run(std::shared_ptr<connection> conn) -> net::awaitable<void>
 ```
 
 The definition of `receiver` and `healthy_checker` above can be found
-in subscriber.cpp.  Adding a loop around `async_run` produces a simple
+in cpp20_subscriber.cpp.  Adding a loop around `async_run` produces a simple
 way to support reconnection _while there are pending operations on the connection_,
 for example, to reconnect to the same address
 
@@ -187,7 +190,7 @@ auto run(std::shared_ptr<connection> conn) -> net::awaitable<void>
 }
 ```
 
-For failover with sentinels see `resolve_with_sentinel.cpp`.  At
+For failover with sentinels see `cpp20_resolve_with_sentinel.cpp`.  At
 this point the reasons for why `async_run` was introduced in Aedis
 might have become apparent to the reader
 
@@ -225,7 +228,7 @@ co_await (conn.async_exec(...) || time.async_wait(...))
 * The cancellation will be ignored if the request has already
   been written to the socket.
 * NOTE: It is usually a better idea to have a healthy checker than adding
-  per request timeout, see subscriber.cpp for an example.
+  per request timeout, see cpp20_subscriber.cpp for an example.
 
 ```cpp
 co_await (conn.async_run(...) || time.async_wait(...))
@@ -302,7 +305,7 @@ std::map<std::string, mystruct> map {...};
 req.push_range("HSET", "key", map);
 ```
 
-Example serialization.cpp shows how store json strings in Redis.
+Example cpp20_serialization.cpp shows how store json strings in Redis.
 
 <a name="responses"></a>
 
@@ -1006,7 +1009,7 @@ Acknowledgement to people that helped shape Aedis
 
 * `connection::async_receive_event` is now being used to communicate
   internal events to the user, such as resolve, connect, push etc. For
-  examples see subscriber.cpp and `connection::event`.
+  examples see cpp20_subscriber.cpp and `connection::event`.
 
 * The `aedis` directory has been moved to `include` to look more
   similar to Boost libraries. Users should now replace `-I/aedis-path`

examples/cpp17_intro.cpp

@@ -45,7 +45,7 @@ auto main() -> int
       auto on_run = [](auto ec)
       {
          if (ec)
-            return log(ec, "on_exec: ");
+            return log(ec, "on_run: ");
       };
 
       // async_exec callback.

examples/cpp20_intro.cpp

@@ -6,15 +6,19 @@
 
 #include <boost/asio.hpp>
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
 #include <aedis.hpp>
 #include "common/common.hpp"
 
 namespace net = boost::asio;
 namespace resp3 = aedis::resp3;
-using namespace net::experimental::awaitable_operators;
 using aedis::adapt;
 
+auto run(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   co_await connect(conn, "127.0.0.1", "6379");
+   co_await conn->async_run();
+}
+
 // Called from the main function (see main.cpp)
 auto async_main() -> net::awaitable<void>
 {
@@ -25,9 +29,10 @@ auto async_main() -> net::awaitable<void>
 
    std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
 
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   co_await connect(conn, "127.0.0.1", "6379");
-   co_await (conn->async_run() || conn->async_exec(req, adapt(resp)));
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, run(conn), net::detached);
+   co_await conn->async_exec(req, adapt(resp));
 
    std::cout << "PING: " << std::get<1>(resp) << std::endl;
 }

examples/cpp20_intro_awaitable_ops.cpp

@@ -0,0 +1,35 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva ([email protected])
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#include <aedis.hpp>
+#include "common/common.hpp"
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using namespace net::experimental::awaitable_operators;
+using aedis::adapt;
+
+// Called from the main function (see main.cpp)
+auto async_main() -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push("PING", "Hello world");
+   req.push("QUIT");
+
+   std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   co_await connect(conn, "127.0.0.1", "6379");
+   co_await (conn->async_run() || conn->async_exec(req, adapt(resp)));
+
+   std::cout << "PING: " << std::get<1>(resp) << std::endl;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

include/aedis/resp3/impl/request.ipp

@@ -9,7 +9,7 @@
 
 namespace aedis::resp3::detail {
 
-auto has_push_response(std::string_view cmd) -> bool
+auto has_response(std::string_view cmd) -> bool
 {
    if (cmd == "SUBSCRIBE") return true;
    if (cmd == "PSUBSCRIBE") return true;

include/aedis/resp3/request.hpp

@@ -62,7 +62,7 @@ void to_bulk(Request& to, T n)
 
 namespace detail {
 
-auto has_push_response(std::string_view cmd) -> bool;
+auto has_response(std::string_view cmd) -> bool;
 
 template <class T>
 struct add_bulk_impl {
@@ -386,7 +386,7 @@ class request {
 private:
    void check_cmd(std::string_view cmd)
    {
-      if (!detail::has_push_response(cmd))
+      if (!detail::has_response(cmd))
          ++commands_;
 
       if (cmd == "HELLO")

tests/conn_exec.cpp

@@ -122,123 +122,3 @@ BOOST_AUTO_TEST_CASE(cancel_request_if_not_connected)
 
    ioc.run();
 }
-
-// TODO: This test is broken.
-BOOST_AUTO_TEST_CASE(request_retry_false)
-{
-   resp3::request req0;
-   req0.get_config().coalesce = false;
-   req0.get_config().cancel_on_connection_lost = true;
-   req0.push("HELLO", 3);
-
-   resp3::request req1;
-   req1.get_config().coalesce = true;
-   req1.get_config().cancel_on_connection_lost = true;
-   req1.push("BLPOP", "any", 0);
-
-   resp3::request req2;
-   req2.get_config().coalesce = true;
-   req2.get_config().cancel_on_connection_lost = false;
-   req2.get_config().cancel_if_unresponded = true;
-   req2.push("PING");
-
-   net::io_context ioc;
-   connection conn{ioc};
-
-   net::steady_timer st{ioc};
-   st.expires_after(std::chrono::seconds{1});
-   st.async_wait([&](auto){
-      // Cancels the request before receiving the response. This
-      // should cause the second request to complete with error
-      // although it has cancel_on_connection_lost = false.
-      conn.cancel(aedis::operation::run);
-   });
-
-   auto const endpoints = resolve();
-   net::connect(conn.next_layer(), endpoints);
-
-   conn.async_exec(req0, adapt(), [](auto ec, auto){
-      BOOST_TEST(!ec);
-   });
-
-   conn.async_exec(req1, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-   });
-
-   conn.async_exec(req2, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-   });
-
-   conn.async_run([](auto ec){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-   });
-
-   ioc.run();
-}
-
-BOOST_AUTO_TEST_CASE(request_retry_true)
-{
-   resp3::request req0;
-   req0.get_config().coalesce = false;
-   req0.get_config().cancel_on_connection_lost = true;
-   req0.push("HELLO", 3);
-
-   resp3::request req1;
-   req1.get_config().coalesce = true;
-   req1.get_config().cancel_on_connection_lost = true;
-   req1.push("BLPOP", "any", 0);
-
-   resp3::request req2;
-   req2.get_config().coalesce = true;
-   req2.get_config().cancel_on_connection_lost = false;
-   req2.get_config().cancel_if_unresponded = false;
-   req2.push("PING");
-
-   resp3::request req3;
-   req3.get_config().coalesce = true;
-   req3.get_config().cancel_on_connection_lost = true;
-   req3.get_config().cancel_if_unresponded = true;
-   req3.push("QUIT");
-
-   net::io_context ioc;
-   connection conn{ioc};
-
-   net::steady_timer st{ioc};
-   st.expires_after(std::chrono::seconds{1});
-   st.async_wait([&](auto){
-      // Cancels the request before receiving the response. This
-      // should cause the second request to complete with error
-      // although it has cancel_on_connection_lost = false.
-      conn.cancel(aedis::operation::run);
-   });
-
-   auto const endpoints = resolve();
-   net::connect(conn.next_layer(), endpoints);
-
-   conn.async_exec(req0, adapt(), [](auto ec, auto){
-      BOOST_TEST(!ec);
-   });
-
-   conn.async_exec(req1, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-   });
-
-   conn.async_exec(req2, adapt(), [&](auto ec, auto){
-      BOOST_TEST(!ec);
-      conn.async_exec(req3, adapt(), [&](auto ec, auto){
-         BOOST_TEST(!ec);
-      });
-   });
-
-   conn.async_run([&](auto ec){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-      conn.reset_stream();
-      net::connect(conn.next_layer(), endpoints);
-      conn.async_run([&](auto ec){
-         std::cout << ec.message() << std::endl;
-         BOOST_TEST(!ec);
-      });
-   });
-
-   ioc.run();
-}