Adds a Corosio API

.github/workflows/ci.yml

@@ -35,7 +35,8 @@ jobs:
     - name: Build a Boost distribution using B2
       run: |
         python3 tools/ci.py build-b2-distro \
-          --toolset ${{ matrix.toolset }}
+          --toolset ${{ matrix.toolset }} \
+          --cxxstd ${{ matrix.cxxstd }}
 
     # No Redis server is available on this job, so integration tests are skipped.
     # Unit tests are built and run via the CMake superproject build.
@@ -127,23 +128,23 @@ jobs:
             cxxstd: '17'
             build-type: 'Debug'
             server: "redis:8.2.1-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: gcc-11
             install: g++-11
             container: ubuntu:22.04
             cxxstd: '20'
             build-type: 'Debug'
             server: "valkey/valkey:8.1.3-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: gcc-11
             install: g++-11
             container: ubuntu:22.04
             cxxstd: '20'
             build-type: 'Release'
             server: "redis:7.4.5-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: gcc-12
             install: g++-12
@@ -159,7 +160,7 @@ jobs:
             cxxstd: '17'
             build-type: 'Debug'
             server: "valkey/valkey:8.1.3-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: gcc-13
             install: g++-13
@@ -189,7 +190,7 @@ jobs:
             cxxstd: '17'
             build-type: 'Debug'
             server: "redis:7.4.5-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: gcc-15
             install: g++-15
@@ -213,23 +214,23 @@ jobs:
             cxxstd: '20'
             build-type: 'Debug'
             server: "redis:7.4.5-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-12
             install: clang-12
             container: ubuntu:22.04
             cxxstd: '20'
             build-type: 'Debug'
             server: "redis:8.2.1-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-13
             install: clang-13
             container: ubuntu:22.04
             cxxstd: '20'
             build-type: 'Debug'
             server: "valkey/valkey:8.1.3-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           # clang-14 is the default in Ubuntu 22.04
           - toolset: clang-14
@@ -238,7 +239,7 @@ jobs:
             cxxstd: '20'
             build-type: 'Debug'
             server: "redis:7.4.5-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-14
             install: 'clang-14 libc++-14-dev libc++abi-14-dev'
@@ -248,7 +249,7 @@ jobs:
             cxxflags: '-stdlib=libc++'
             ldflags: '-lc++'
             server: "redis:8.2.1-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-14
             install: 'clang-14 libc++-14-dev libc++abi-14-dev'
@@ -265,7 +266,7 @@ jobs:
             cxxstd: '20'
             build-type: 'Debug'
             server: "redis:7.4.5-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-16
             install: clang-16
@@ -274,7 +275,7 @@ jobs:
             build-type: 'Debug'
             cxxflags: '-DBOOST_ASIO_DISABLE_LOCAL_SOCKETS=1' # If a system has no UNIX socket support, we build correctly
             server: "redis:8.2.1-alpine"
-            corosio-tests: '0'
+            corosio-api: '0'
 
           - toolset: clang-17
             install: clang-17
@@ -392,7 +393,8 @@ jobs:
     - name: Build a Boost distribution using B2
       run: |
         docker exec builder /boost-redis/tools/ci.py build-b2-distro \
-          --toolset ${{ matrix.toolset }}
+          --toolset ${{ matrix.toolset }} \
+          --cxxstd ${{ matrix.cxxstd }}
 
     # The CMake superproject build also drives the project tests, including
     # integration tests against the Redis server set up above.
@@ -402,6 +404,7 @@ jobs:
           --build-type ${{ matrix.build-type }} \
           --cxxstd ${{ matrix.cxxstd }} \
           --toolset ${{ matrix.toolset }} \
+          --corosio-api ${{ matrix.corosio-api == '' && '1' || matrix.corosio-api }} \
           "--cxxflags=${{ matrix.cxxflags }} -Werror" \
           "--ldflags=${{ matrix.ldflags }}"
 
@@ -411,6 +414,7 @@ jobs:
           --build-type ${{ matrix.build-type }} \
           --cxxstd ${{ matrix.cxxstd }} \
           --toolset ${{ matrix.toolset }} \
+          --corosio-api ${{ matrix.corosio-api == '' && '1' || matrix.corosio-api }} \
           "--cxxflags=${{ matrix.cxxflags }} -Werror" \
           "--ldflags=${{ matrix.ldflags }}"
 
@@ -420,6 +424,7 @@ jobs:
           --build-type ${{ matrix.build-type }} \
           --cxxstd ${{ matrix.cxxstd }} \
           --toolset ${{ matrix.toolset }} \
+          --corosio-api ${{ matrix.corosio-api == '' && '1' || matrix.corosio-api }} \
           "--cxxflags=${{ matrix.cxxflags }} -Werror" \
           "--ldflags=${{ matrix.ldflags }}"
 
@@ -429,6 +434,7 @@ jobs:
           --build-type ${{ matrix.build-type }} \
           --cxxstd ${{ matrix.cxxstd }} \
           --toolset ${{ matrix.toolset }} \
+          --corosio-api ${{ matrix.corosio-api == '' && '1' || matrix.corosio-api }} \
           "--cxxflags=${{ matrix.cxxflags }} -Werror" \
           "--ldflags=${{ matrix.ldflags }}"
 

CMakeLists.txt

@@ -2,12 +2,6 @@ cmake_minimum_required(VERSION 3.8...4.2)
 
 project(boost_redis VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
-# Library
-add_library(boost_redis INTERFACE)
-add_library(Boost::redis ALIAS boost_redis)
-target_include_directories(boost_redis INTERFACE include)
-target_compile_features(boost_redis INTERFACE cxx_std_17)
-
 # Dependencies
 # Boost dependencies should be already available.
 # If other dependencies are not found, we bail out
@@ -22,24 +16,56 @@ if(NOT OpenSSL_FOUND)
   return()
 endif()
 
-# This is generated by boostdep
-target_link_libraries(boost_redis
+# Allow explicit control over the Corosio API.
+# TODO: this is temporary, until Capy gets into Boost.
+# https://github.com/cppalliance/capy/issues/274 
+option(BOOST_REDIS_COROSIO_API OFF "Whether to build the Corosio API")
+
+# Library (common)
+add_library(boost_redis_proto INTERFACE)
+add_library(Boost::redis_proto ALIAS boost_redis_proto)
+target_include_directories(boost_redis_proto INTERFACE include)
+target_compile_features(boost_redis_proto INTERFACE cxx_std_17)
+target_link_libraries(boost_redis_proto
   INTERFACE
-    Boost::asio
     Boost::assert
     Boost::core
     Boost::mp11
     Boost::system
     Boost::throw_exception
+)
+
+# Library (Asio)
+add_library(boost_redis INTERFACE)
+add_library(Boost::redis ALIAS boost_redis)
+target_link_libraries(boost_redis
+  INTERFACE
+    Boost::redis_proto
+    Boost::asio
     Threads::Threads
     OpenSSL::Crypto
     OpenSSL::SSL
 )
 
+# Library (Corosio)
+if (BOOST_REDIS_COROSIO_API)
+  add_library(boost_redis_corosio INTERFACE)
+  add_library(Boost::redis_corosio ALIAS boost_redis_corosio)
+  target_compile_features(boost_redis_corosio INTERFACE cxx_std_20)
+  target_link_libraries(boost_redis_corosio
+    INTERFACE
+      Boost::redis_proto
+      Boost::capy
+      Boost::corosio
+      Boost::corosio_openssl
+  )
+endif()
+
 # Don't run integration testing unless explicitly requested, since these require a running server
 option(BOOST_REDIS_INTEGRATION_TESTS OFF "Whether to build and run integration tests or not")
 mark_as_advanced(BOOST_REDIS_INTEGRATION_TESTS)
 
+
 # Examples and tests
 if(BUILD_TESTING)
   # Custom target tests; required by the Boost superproject
@@ -59,3 +85,15 @@ if(BUILD_TESTING)
     add_subdirectory(example)
   endif()
 endif()
+
+if(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)
+  set(_boost_redis_install_targets boost_redis boost_redis_proto)
+  if (BOOST_REDIS_COROSIO_API)
+    list(APPEND _boost_redis_install_targets boost_redis_corosio)
+  endif()
+  boost_install(
+    TARGETS ${_boost_redis_install_targets}
+    VERSION ${BOOST_SUPERPROJECT_VERSION}
+    HEADER_DIRECTORY include
+  )
+endif()

README.md

@@ -1,7 +1,8 @@
 # Boost.Redis
 
-Boost.Redis is a high-level [Redis](https://redis.io/) client library built on top of
+Boost.Redis is a high-level [Redis](https://redis.io/) client library for
 [Boost.Asio](https://www.boost.org/doc/libs/latest/doc/html/boost_asio.html)
+and [Corosio](https://github.com/cppalliance/corosio/)
 that implements the Redis protocol
 [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md).
 
@@ -12,18 +13,24 @@ Full documentation is [here](https://www.boost.org/doc/libs/master/libs/redis/in
 The requirements for using Boost.Redis are:
 
 * Boost 1.84 or higher. Boost.Redis is included in Boost installations since Boost 1.84.
-* C++17 or higher. Supported compilers include gcc 11 and later, clang 11 and later, and Visual Studio 16 (2019) and later.
+* When using Asio, C++17 or higher. Supported compilers include gcc 11 and later, clang 11 and later, and MSVC 14.20 and later.
+* When using Corosio, C++20 or higher. Supported compilers include gcc 12 and later, clang 17 and later, MSVC 14.34 and later.
 * Redis 6 or higher (must support RESP3).
 * OpenSSL.
 
-The documentation assumes basic-level knowledge about [Redis](https://redis.io/docs/) and [Boost.Asio](https://www.boost.org/doc/libs/latest/doc/html/boost_asio.html).
+The documentation assumes basic-level knowledge about [Redis](https://redis.io/docs/) and either Boost.Asio or Corosio.
 
 ## Building the library
 
 To use the library it is necessary to include the following:
 
 ```cpp
+// If using the Asio API
 #include <boost/redis/src.hpp>
+
+// If using the Corosio API
+#include <boost/redis/src/proto.hpp>
+#include <boost/redis/src/corosio.hpp>
 ```
 
 in exactly one source file in your applications. Otherwise, the library is header-only.
@@ -77,6 +84,55 @@ The roles played by the `async_run` and `async_exec` functions are:
   be called from multiple places in your code concurrently.
 * `connection::async_run`: keeps the connection healthy. It takes care of hostname resolution, session establishment, health-checks, reconnection and coordination of low-level read and write operations. It should be called only once per connection, regardless of the number of requests to execute.
 
+The Corosio API works similarly:
+
+```cpp
+#include <boost/redis/co_connection.hpp>
+#include <boost/redis/config.hpp>
+
+#include <boost/capy/ex/run_async.hpp>
+#include <boost/capy/io_task.hpp>
+#include <boost/capy/task.hpp>
+#include <boost/capy/when_any.hpp>
+#include <boost/corosio/io_context.hpp>
+
+#include <exception>
+#include <iostream>
+
+namespace capy = boost::capy;
+using namespace boost::redis;
+namespace corosio = boost::corosio;
+
+capy::io_task<> run_request(co_connection& conn)
+{
+   // A request containing only a ping command.
+   request req;
+   req.push("PING", "Hello world");
+
+   // Response where the PONG response will be stored.
+   response<std::string> resp;
+
+   // Executes the request.
+   auto [ec] = co_await conn.exec(req, resp);
+   if (ec) {
+      std::cout << "Error executing PING: " << ec << std::endl;
+   } else {
+      std::cout << "PING value: " << std::get<0>(resp).value() << std::endl;
+   }
+
+   co_return {};
+}
+
+capy::task<void> co_main()
+{
+   // Create a connection
+   co_connection conn{co_await capy::this_coro::executor};
+
+   // Run the connection and the PING request, in parallel
+   co_await capy::when_any(run_request(conn), conn.run(config{}));
+}
+```
+
 ## Server pushes
 
 Redis servers can also send a variety of pushes to the client. Some of

benchmarks/CMakeLists.txt

@@ -1,11 +1,13 @@
 
 add_library(boost_redis_benchmarks_options INTERFACE)
-target_link_libraries(boost_redis_benchmarks_options INTERFACE boost_redis_src)
+target_link_libraries(boost_redis_benchmarks_options INTERFACE boost_redis_asio_src)
 target_link_libraries(boost_redis_benchmarks_options INTERFACE boost_redis_project_options)
 target_compile_features(boost_redis_benchmarks_options INTERFACE cxx_std_20)
 
 add_executable(boost_redis_echo_server_client cpp/asio/echo_server_client.cpp)
 target_link_libraries(boost_redis_echo_server_client PRIVATE boost_redis_benchmarks_options)
+add_dependencies(tests boost_redis_echo_server_client)
 
 add_executable(boost_redis_echo_server_direct cpp/asio/echo_server_direct.cpp)
 target_link_libraries(boost_redis_echo_server_direct PRIVATE boost_redis_benchmarks_options)
+add_dependencies(tests boost_redis_echo_server_direct)

build.jam

@@ -5,22 +5,36 @@
 
 require-b2 5.2 ;
 
-constant boost_dependencies :
-    /boost/asio//boost_asio
+constant boost_dependencies_proto :
     /boost/assert//boost_assert
     /boost/core//boost_core
     /boost/mp11//boost_mp11
     /boost/system//boost_system
-    /boost/throw_exception//boost_throw_exception ;
+    /boost/throw_exception//boost_throw_exception
+;
+
+constant boost_dependencies_asio :
+    /boost/redis//boost_redis_proto
+    /boost/asio//boost_asio
+;
+
+constant boost_dependencies_corosio :
+    /boost/redis//boost_redis_proto
+    /boost/capy//boost_capy
+    /boost/corosio//boost_corosio
+    /boost/corosio//boost_corosio_openssl
+;
 
 project /boost/redis
     : common-requirements
         <include>include
     ;
 
 explicit
-    [ alias boost_redis : : : : <library>$(boost_dependencies) ]
-    [ alias all : boost_redis test ]
+    [ alias boost_redis_proto : : : : <library>$(boost_dependencies_proto) ]
+    [ alias boost_redis : : : : <library>$(boost_dependencies_asio) ]
+    [ alias boost_redis_corosio : : : : <library>$(boost_dependencies_corosio) ]
+    [ alias all : boost_redis_proto boost_redis boost_redis_corosio test ]
     ;
 
 call-if : boost-library redis