Implements non-member async_run for plain connections.

This function will resolve and connect before calling member async_run.

Author: mzimbres

CMakeLists.txt

@@ -59,9 +59,9 @@ include_directories(include)
 #=======================================================================
 
 add_library(common STATIC
-   examples/common/common.cpp
-   examples/common/main.cpp
-   examples/common/boost_redis.cpp
+   examples/start.cpp
+   examples/main.cpp
+   examples/boost_redis.cpp
 )
 target_compile_features(common PUBLIC cxx_std_20)
 if (MSVC)
@@ -98,12 +98,10 @@ if (MSVC)
     target_compile_definitions(cpp17_intro PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
+if (NOT MSVC)
 add_executable(cpp17_intro_sync examples/cpp17_intro_sync.cpp)
 target_compile_features(cpp17_intro_sync PUBLIC cxx_std_17)
 add_test(cpp17_intro_sync cpp17_intro_sync)
-if (MSVC)
-    target_compile_options(cpp17_intro_sync PRIVATE /bigobj)
-    target_compile_definitions(cpp17_intro_sync PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
 if (NOT MSVC)
@@ -320,6 +318,14 @@ target_link_libraries(test_conn_check_health common)
 add_test(test_conn_check_health test_conn_check_health)
 endif()
 
+add_executable(test_run tests/run.cpp)
+target_compile_features(test_run PUBLIC cxx_std_17)
+add_test(test_run test_run)
+if (MSVC)
+    target_compile_options(test_run PRIVATE /bigobj)
+    target_compile_definitions(test_run PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 # Install
 #=======================================================================
 

README.md

@@ -831,6 +831,9 @@ https://lists.boost.org/Archives/boost/2023/01/253944.php.
 * Adds a function that performs health checks, see
   `boost::redis::experimental::async_check_health`.
 
+* Adds non-member `async_run` function that resolves, connects and
+  calls member `async_run` on a connection object.
+
 ### v1.4.0-1
 
 * Renames `retry_on_connection_lost` to `cancel_if_unresponded`.  (v1.4.1)

examples/common/boost_redis.cpp renamed to examples/boost_redis.cpp

@@ -10,16 +10,12 @@
 #include <boost/redis/src.hpp>
 
 namespace net = boost::asio;
-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)
-{
-   std::clog << prefix << ec.message() << std::endl;
-}
+using boost::redis::connection;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::ignore_t;
+using boost::redis::async_run;
+using namespace std::chrono_literals;
 
 auto main(int argc, char * argv[]) -> int
 {
@@ -36,67 +32,29 @@ auto main(int argc, char * argv[]) -> int
       request req;
       req.push("HELLO", 3);
       req.push("PING", "Hello world");
-      req.push("QUIT");
 
       // The response.
-      response<ignore_t, std::string, ignore_t> resp;
+      response<ignore_t, std::string> resp;
 
       net::io_context ioc;
+      connection conn{ioc};
 
-      // IO objects.
-      net::ip::tcp::resolver resv{ioc};
-      redis::connection conn{ioc};
-
-      // Resolve endpoints.
-      net::ip::tcp::resolver::results_type endpoints;
-
-      // async_run callback.
-      auto on_run = [](auto ec)
-      {
-         if (ec)
-            return log(ec, "on_run: ");
-      };
-
-      // async_exec callback.
-      auto on_exec = [&](auto ec, auto)
-      {
-         if (ec) {
-            conn.cancel(operation::run);
-            return log(ec, "on_exec: ");
-         }
+      async_run(conn, host, port, 10s, 10s, [&](auto){
+         conn.cancel();
+      });
 
-         std::cout << "PING: " << std::get<1>(resp).value() << std::endl;
-      };
-
-      // Connect callback.
-      auto on_connect = [&](auto ec, auto)
-      {
-         if (ec)
-            return log(ec, "on_connect: ");
-
-         conn.async_run(on_run);
-         conn.async_exec(req, resp, on_exec);
-      };
-
-      // Resolve callback.
-      auto on_resolve = [&](auto ec, auto const& addrs)
-      {
-         if (ec)
-            return log(ec, "on_resolve: ");
-
-         endpoints = addrs;
-         net::async_connect(conn.next_layer(), endpoints, on_connect);
-      };
-
-      resv.async_resolve(host, port, on_resolve);
+      conn.async_exec(req, resp, [&](auto ec, auto){
+         if (!ec)
+            std::cout << "PING: " << std::get<1>(resp).value() << std::endl;
+         conn.cancel();
+      });
 
       ioc.run();
       return 0;
 
    } catch (std::exception const& e) {
       std::cerr << "Error: " << e.what() << std::endl;
    }
-
    return 1;
 }
 

examples/common/common.cpp

@@ -6,19 +6,25 @@
 
 #include <tuple>
 #include <string>
+#include <chrono>
 #include <thread>
 #include <iostream>
 #include <boost/asio.hpp>
 #include <boost/redis.hpp>
+#include <boost/redis/check_health.hpp>
 
 // Include this in no more than one .cpp file.
 #include <boost/redis/src.hpp>
 
 namespace net = boost::asio;
 using connection = boost::redis::connection;
+using boost::redis::operation;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
+using boost::redis::async_run;
+using boost::redis::async_check_health;
+using namespace std::chrono_literals;
 
 template <class Response>
 auto exec(std::shared_ptr<connection> conn, request const& req, Response& resp)
@@ -29,9 +35,6 @@ auto exec(std::shared_ptr<connection> conn, request const& req, Response& resp)
       (net::use_future).get();
 }
 
-auto logger = [](auto const& ec)
-   { std::clog << "Run: " << ec.message() << std::endl; };
-
 auto main(int argc, char * argv[]) -> int
 {
    try {
@@ -47,17 +50,17 @@ auto main(int argc, char * argv[]) -> int
 
       auto conn = std::make_shared<connection>(ioc);
 
-      // Resolves the address
-      net::ip::tcp::resolver resv{ioc};
-      auto const res = resv.resolve(host, port);
+      // Starts a thread that will can io_context::run on which the
+      // connection will run.
+      std::thread t{[&ioc, conn, host, port]() {
+         async_run(*conn, host, port, 10s, 10s, [conn](auto){
+            conn->cancel();
+         });
 
-      // Connect to Redis
-      net::connect(conn->next_layer(), res);
+         async_check_health(*conn, "Boost.Redis", 2s, [conn](auto) {
+            conn->cancel();
+         });
 
-      // Starts a thread that will can io_context::run on which
-      // the connection will run.
-      std::thread t{[conn, &ioc]() {
-         conn->async_run(logger);
          ioc.run();
       }};
 

examples/common/common.hpp

@@ -11,17 +11,17 @@ namespace net = boost::asio;
 #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
 #include <boost/asio/experimental/awaitable_operators.hpp>
 #include <boost/redis.hpp>
-#include <boost/redis/experimental/run.hpp>
+#include <boost/redis/check_health.hpp>
 #include <unistd.h>
 
-#include "common/common.hpp"
-
 using namespace net::experimental::awaitable_operators;
 using stream_descriptor = net::use_awaitable_t<>::as_default_on_t<net::posix::stream_descriptor>;
 using signal_set = net::use_awaitable_t<>::as_default_on_t<net::signal_set>;
 using boost::redis::request;
 using boost::redis::generic_response;
-using boost::redis::experimental::async_check_health;
+using boost::redis::async_check_health;
+using boost::redis::async_run;
+using connection = boost::asio::use_awaitable_t<>::as_default_on_t<boost::redis::connection>;
 
 // Chat over Redis pubsub. To test, run this program from multiple
 // terminals and type messages to stdin.
@@ -60,8 +60,7 @@ auto co_main(std::string host, std::string port) -> net::awaitable<void>
    req.push("HELLO", 3);
    req.push("SUBSCRIBE", "chat-channel");
 
-   co_await connect(conn, host, port);
-   co_await ((conn->async_run() || publisher(stream, conn) || receiver(conn) ||
+   co_await ((async_run(*conn, host, port) || publisher(stream, conn) || receiver(conn) ||
          async_check_health(*conn) || sig.async_wait()) &&
          conn->async_exec(req));
 }

examples/cpp17_intro.cpp

@@ -6,19 +6,18 @@
 
 #include <boost/asio.hpp>
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
 #include <boost/redis.hpp>
 #include <map>
 #include <vector>
-
-#include "common/common.hpp"
+#include <iostream>
 
 namespace net = boost::asio;
 namespace redis = boost::redis;
-using namespace net::experimental::awaitable_operators;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
+using boost::redis::async_run;
+using connection = boost::asio::use_awaitable_t<>::as_default_on_t<boost::redis::connection>;
 
 void print(std::map<std::string, std::string> const& cont)
 {
@@ -34,8 +33,7 @@ void print(std::vector<int> const& cont)
 
 auto run(std::shared_ptr<connection> conn, std::string host, std::string port) -> net::awaitable<void>
 {
-   co_await connect(conn, host, port);
-   co_await conn->async_run();
+   co_await async_run(*conn, host, port);
 }
 
 // Stores the content of some STL containers in Redis.