Adds more doc to node class.

remove duplicate line in cmake

.github/workflows/ci.yml

@@ -3,6 +3,92 @@ name: CI
 on: [push, pull_request]
 
 jobs:
+  windows:
+    name: "${{matrix.generator}} ${{matrix.toolset}} Boost ${{matrix.boost_version}} ${{matrix.build_type}} ${{matrix.name_args}}"
+    runs-on: ${{matrix.os}}
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        boost_version: ["1.80.0"]
+        os: [windows-2019, windows-2022]
+        toolset: [v142, v143]
+        build_type: [Release]
+        generator: ["Visual Studio 16 2019", "Visual Studio 17 2022"]
+        config_args: [""]
+        build_args: [""]
+        name_args: [""]
+        exclude:
+          - { os: windows-2019, toolset: v143 }
+          - { os: windows-2019, generator: "Visual Studio 17 2022" }
+          - { os: windows-2022, generator: "Visual Studio 16 2019" }
+          # The following combinations are not available through install-boost
+          - { boost_version: "1.80.0", toolset: v143 }
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Add boost toolset to environment
+      if: contains(fromJson('["1.80.0"]'), matrix.boost_version)
+      run: echo BOOST_TOOLSET=$(echo "msvc") >> $GITHUB_ENV
+
+    # The platform_version passed to boost-install determines the msvc toolset version for which static libs are installed.
+    - name: Add boost platform version to environment
+      run: |
+        declare -A toolset_to_platform_version=( [v142]="2019" [v143]="2022" )
+        key=$(echo "${{matrix.toolset}}")
+        echo BOOST_PLATFORM_VERSION="${toolset_to_platform_version[$key]}" >> $GITHUB_ENV
+
+    - name: Add boost install path to environment
+      run: echo BOOST_INSTALL_PATH="${GITHUB_WORKSPACE}/boost-${{matrix.boost_version}}${BOOST_TOOLSET}${BOOST_PLATFORM_VERSION}" >> $GITHUB_ENV
+
+    - name: Add build type configuration to environment
+      run: echo BUILD_CONFIG_ARG="--config ${{matrix.build_type}}" >> $GITHUB_ENV
+
+    - name: Cache Boost installation
+      id: cache-boost
+      uses: actions/cache@v3
+      with:
+        path: ${{env.BOOST_INSTALL_PATH}}
+        key: ${{matrix.boost_version}}${{env.BOOST_TOOLSET}}${{env.BOOST_PLATFORM_VERSION}}
+
+    - name: Install Boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      uses: MarkusJx/install-boost@v2.4.1
+      with:
+        boost_version: ${{matrix.boost_version}}
+        toolset: ${{env.BOOST_TOOLSET}}
+        boost_install_dir: ${{env.BOOST_INSTALL_PATH}}
+        platform_version: ${{env.BOOST_PLATFORM_VERSION}}
+        arch: null
+
+    - name: Install packages
+      run: cinst openssl
+
+    - name: Create build directory
+      run: mkdir build
+
+    - name: Configure
+      working-directory: build
+      run: |
+        cmake -T "${{matrix.toolset}}" \
+              -G "${{matrix.generator}}" \
+              ${{matrix.config_args}} \
+              ${BOOST_COMPILER_ARG}\
+              "${GITHUB_WORKSPACE}"
+      env:
+        BOOST_ROOT: ${{env.BOOST_INSTALL_PATH}}/boost
+
+    - name: Build
+      working-directory: build
+      run: |
+        cmake --build . ${BUILD_CONFIG_ARG} ${{matrix.build_args}}
+
   posix:
     defaults:
       run:
@@ -12,7 +98,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - { toolset: gcc,   compiler: g++-10,     install: g++-10,   os: ubuntu-22.04, cxxstd: 'c++17' }
           - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxstd: 'c++17' }
           - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxstd: 'c++20' }
           - { toolset: clang, compiler: clang++-11, install: clang-11, os: ubuntu-22.04, cxxstd: 'c++17' }
@@ -35,7 +120,7 @@ jobs:
       uses: MarkusJx/install-boost@v2.3.0
       id: install-boost
       with:
-        boost_version: 1.79.0
+        boost_version: 1.80.0
         platform_version: 22.04
     - name: Run CMake
       run: |

.github/workflows/coverage.yml

@@ -30,7 +30,7 @@ jobs:
       uses: MarkusJx/install-boost@v2.3.0
       id: install-boost
       with:
-        boost_version: 1.79.0
+        boost_version: 1.80.0
         platform_version: 22.04
     - name: Run CMake
       run: |

CMakeLists.txt

@@ -10,8 +10,8 @@ cmake_minimum_required(VERSION 3.14)
 
 project(
     Aedis
-    VERSION 1.2.0
-    DESCRIPTION "A redis client designed for performance and scalability"
+    VERSION 1.4.1
+    DESCRIPTION "A redis client library"
     HOMEPAGE_URL "https://mzimbres.github.io/aedis"
     LANGUAGES CXX
 )
@@ -21,28 +21,34 @@ target_include_directories(aedis INTERFACE
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
     $<INSTALL_INTERFACE:include>
 )
-target_link_libraries(aedis
+
+target_link_libraries(
+  aedis
   INTERFACE
     Boost::asio
     Boost::assert
     Boost::config
     Boost::core
     Boost::mp11
-    Boost::optional
     Boost::system
     Boost::utility
-    Boost::winapi
 )
 
 target_compile_features(aedis INTERFACE cxx_std_17)
 
+# Asio bases C++ feature detection on __cplusplus. Make MSVC
+# define it correctly
+if (MSVC)
+    target_compile_options(aedis INTERFACE /Zc:__cplusplus)
+endif()
+
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file(
     "${PROJECT_BINARY_DIR}/AedisConfigVersion.cmake"
     COMPATIBILITY AnyNewerVersion
 )
 
-find_package(Boost 1.79 REQUIRED)
+find_package(Boost 1.80 REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(OpenSSL REQUIRED)
@@ -50,82 +56,248 @@ find_package(OpenSSL REQUIRED)
 enable_testing()
 include_directories(include)
 
+# Main function for the examples.
+#=======================================================================
+
+add_library(common STATIC
+   examples/common/common.cpp
+   examples/common/main.cpp
+   examples/common/aedis.cpp
+)
+target_compile_features(common PUBLIC cxx_std_20)
+if (MSVC)
+    target_compile_options(common PRIVATE /bigobj)
+    target_compile_definitions(common PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 # Executables
 #=======================================================================
 
-#add_executable(intro_sync examples/intro_sync.cpp) // Uncomment after update to Boost 1.80
-add_executable(chat_room examples/chat_room.cpp)
-add_executable(containers examples/containers.cpp)
-add_executable(echo_server examples/echo_server.cpp)
+add_executable(cpp20_intro examples/cpp20_intro.cpp)
+target_link_libraries(cpp20_intro common)
+target_compile_features(cpp20_intro PUBLIC cxx_std_20)
+add_test(cpp20_intro cpp20_intro)
+if (MSVC)
+    target_compile_options(cpp20_intro PRIVATE /bigobj)
+    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)
+if (MSVC)
+    target_compile_options(cpp17_intro PRIVATE /bigobj)
+    target_compile_definitions(cpp17_intro PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+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()
+
+add_executable(cpp20_chat_room examples/cpp20_chat_room.cpp)
+target_compile_features(cpp20_chat_room PUBLIC cxx_std_20)
+target_link_libraries(cpp20_chat_room common)
+if (MSVC)
+    target_compile_options(cpp20_chat_room PRIVATE /bigobj)
+    target_compile_definitions(cpp20_chat_room PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_containers examples/cpp20_containers.cpp)
+target_compile_features(cpp20_containers PUBLIC cxx_std_20)
+target_link_libraries(cpp20_containers common)
+add_test(cpp20_containers cpp20_containers)
+if (MSVC)
+    target_compile_options(cpp20_containers PRIVATE /bigobj)
+    target_compile_definitions(cpp20_containers PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_echo_server examples/cpp20_echo_server.cpp)
+target_compile_features(cpp20_echo_server PUBLIC cxx_std_20)
+target_link_libraries(cpp20_echo_server common)
+if (MSVC)
+    target_compile_options(cpp20_echo_server PRIVATE /bigobj)
+    target_compile_definitions(cpp20_echo_server PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_resolve_with_sentinel examples/cpp20_resolve_with_sentinel.cpp)
+target_compile_features(cpp20_resolve_with_sentinel PUBLIC cxx_std_20)
+target_link_libraries(cpp20_resolve_with_sentinel common)
+#add_test(cpp20_resolve_with_sentinel cpp20_resolve_with_sentinel)
+if (MSVC)
+    target_compile_options(cpp20_resolve_with_sentinel PRIVATE /bigobj)
+    target_compile_definitions(cpp20_resolve_with_sentinel PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_serialization examples/cpp20_serialization.cpp)
+target_compile_features(cpp20_serialization PUBLIC cxx_std_20)
+target_link_libraries(cpp20_serialization common)
+add_test(cpp20_serialization cpp20_serialization)
+if (MSVC)
+    target_compile_options(cpp20_serialization PRIVATE /bigobj)
+    target_compile_definitions(cpp20_serialization PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_subscriber examples/cpp20_subscriber.cpp)
+target_compile_features(cpp20_subscriber PUBLIC cxx_std_20)
+target_link_libraries(cpp20_subscriber common)
+if (MSVC)
+    target_compile_options(cpp20_subscriber PRIVATE /bigobj)
+    target_compile_definitions(cpp20_subscriber PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_intro_tls examples/cpp20_intro_tls.cpp)
+target_compile_features(cpp20_intro_tls PUBLIC cxx_std_20)
+add_test(cpp20_intro_tls cpp20_intro_tls)
+target_link_libraries(cpp20_intro_tls OpenSSL::Crypto OpenSSL::SSL)
+target_link_libraries(cpp20_intro_tls common)
+if (MSVC)
+    target_compile_options(cpp20_intro_tls PRIVATE /bigobj)
+    target_compile_definitions(cpp20_intro_tls PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_low_level_async examples/cpp20_low_level_async.cpp)
+target_compile_features(cpp20_low_level_async PUBLIC cxx_std_20)
+add_test(cpp20_low_level_async cpp20_low_level_async)
+target_link_libraries(cpp20_low_level_async common)
+if (MSVC)
+    target_compile_options(cpp20_low_level_async PRIVATE /bigobj)
+    target_compile_definitions(cpp20_low_level_async PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
 add_executable(echo_server_client benchmarks/cpp/asio/echo_server_client.cpp)
-add_executable(echo_server_direct benchmarks/cpp/asio/echo_server_direct.cpp)
-add_executable(intro examples/intro.cpp)
-add_executable(intro_tls examples/intro_tls.cpp)
-add_executable(low_level_sync examples/low_level_sync.cpp)
-add_executable(serialization examples/serialization.cpp)
-add_executable(subscriber examples/subscriber.cpp)
-add_executable(subscriber_sentinel examples/subscriber_sentinel.cpp)
-add_executable(test_conn_connect tests/conn_connect.cpp)
-add_executable(test_conn_exec tests/conn_exec.cpp)
-add_executable(test_conn_push tests/conn_push.cpp)
-add_executable(test_conn_quit tests/conn_quit.cpp)
-add_executable(test_conn_quit_coalesce tests/conn_quit_coalesce.cpp)
-add_executable(test_conn_reconnect tests/conn_reconnect.cpp)
-add_executable(test_conn_tls tests/conn_tls.cpp)
-add_executable(test_low_level tests/low_level.cpp)
-add_executable(test_conn_run_cancel tests/conn_run_cancel.cpp)
-add_executable(test_conn_exec_cancel tests/conn_exec_cancel.cpp)
-add_executable(test_conn_echo_stress tests/conn_echo_stress.cpp)
-add_executable(test_request tests/request.cpp)
-
-target_compile_features(chat_room PUBLIC cxx_std_20)
-target_compile_features(containers PUBLIC cxx_std_20)
-target_compile_features(echo_server PUBLIC cxx_std_20)
 target_compile_features(echo_server_client PUBLIC cxx_std_20)
+if (MSVC)
+    target_compile_options(echo_server_client PRIVATE /bigobj)
+    target_compile_definitions(echo_server_client PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(echo_server_direct benchmarks/cpp/asio/echo_server_direct.cpp)
 target_compile_features(echo_server_direct PUBLIC cxx_std_20)
-target_compile_features(intro PUBLIC cxx_std_17)
-target_compile_features(intro_tls PUBLIC cxx_std_17)
-target_compile_features(low_level_sync PUBLIC cxx_std_17)
-target_compile_features(serialization PUBLIC cxx_std_17)
-target_compile_features(subscriber PUBLIC cxx_std_20)
-target_compile_features(subscriber_sentinel PUBLIC cxx_std_20)
-target_compile_features(test_conn_connect PUBLIC cxx_std_17)
+if (MSVC)
+    target_compile_options(echo_server_direct PRIVATE /bigobj)
+    target_compile_definitions(echo_server_direct PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp17_low_level_sync examples/cpp17_low_level_sync.cpp)
+target_compile_features(cpp17_low_level_sync PUBLIC cxx_std_17)
+add_test(cpp17_low_level_sync cpp17_low_level_sync)
+if (MSVC)
+    target_compile_options(cpp17_low_level_sync PRIVATE /bigobj)
+    target_compile_definitions(cpp17_low_level_sync PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_exec tests/conn_exec.cpp)
 target_compile_features(test_conn_exec PUBLIC cxx_std_20)
-target_compile_features(test_conn_push PUBLIC cxx_std_20)
-target_compile_features(test_conn_quit PUBLIC cxx_std_17)
-target_compile_features(test_conn_quit_coalesce PUBLIC cxx_std_17)
-target_compile_features(test_conn_reconnect PUBLIC cxx_std_20)
-target_compile_features(test_conn_tls PUBLIC cxx_std_17)
-target_compile_features(test_low_level PUBLIC cxx_std_17)
-target_compile_features(test_conn_run_cancel PUBLIC cxx_std_20)
-target_compile_features(test_conn_exec_cancel PUBLIC cxx_std_20)
-target_compile_features(test_conn_echo_stress PUBLIC cxx_std_20)
-target_compile_features(test_request PUBLIC cxx_std_17)
-
-target_link_libraries(intro_tls OpenSSL::Crypto OpenSSL::SSL)
-target_link_libraries(test_conn_tls OpenSSL::Crypto OpenSSL::SSL)
-
-# Tests
-#=======================================================================
-
-add_test(containers containers)
-add_test(intro intro)
-add_test(intro_tls intro_tls)
-#add_test(intro_sync intro_sync)
-add_test(serialization serialization)
-add_test(low_level_sync low_level_sync)
-add_test(test_low_level test_low_level)
 add_test(test_conn_exec test_conn_exec)
-add_test(test_conn_connect test_conn_connect)
+if (MSVC)
+    target_compile_options(test_conn_exec PRIVATE /bigobj)
+    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)
+if (MSVC)
+    target_compile_options(test_conn_push PRIVATE /bigobj)
+    target_compile_definitions(test_conn_push PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_quit tests/conn_quit.cpp)
+target_compile_features(test_conn_quit PUBLIC cxx_std_17)
 add_test(test_conn_quit test_conn_quit)
+if (MSVC)
+    target_compile_options(test_conn_quit PRIVATE /bigobj)
+    target_compile_definitions(test_conn_quit PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_quit_coalesce tests/conn_quit_coalesce.cpp)
 add_test(test_conn_quit_coalesce test_conn_quit_coalesce)
+target_compile_features(test_conn_quit_coalesce PUBLIC cxx_std_17)
+if (MSVC)
+    target_compile_options(test_conn_quit_coalesce PRIVATE /bigobj)
+    target_compile_definitions(test_conn_quit_coalesce PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_reconnect tests/conn_reconnect.cpp)
+target_compile_features(test_conn_reconnect PUBLIC cxx_std_20)
+target_link_libraries(test_conn_reconnect common)
 add_test(test_conn_reconnect test_conn_reconnect)
+if (MSVC)
+    target_compile_options(test_conn_reconnect PRIVATE /bigobj)
+    target_compile_definitions(test_conn_reconnect PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_tls tests/conn_tls.cpp)
 add_test(test_conn_tls test_conn_tls)
+target_compile_features(test_conn_tls PUBLIC cxx_std_17)
+target_link_libraries(test_conn_tls OpenSSL::Crypto OpenSSL::SSL)
+if (MSVC)
+    target_compile_options(test_conn_tls PRIVATE /bigobj)
+    target_compile_definitions(test_conn_tls PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_low_level tests/low_level.cpp)
+target_compile_features(test_low_level PUBLIC cxx_std_17)
+add_test(test_low_level test_low_level)
+if (MSVC)
+    target_compile_options(test_low_level PRIVATE /bigobj)
+    target_compile_definitions(test_low_level PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_run_cancel tests/conn_run_cancel.cpp)
+target_compile_features(test_conn_run_cancel PUBLIC cxx_std_20)
 add_test(test_conn_run_cancel test_conn_run_cancel)
+if (MSVC)
+    target_compile_options(test_conn_run_cancel PRIVATE /bigobj)
+    target_compile_definitions(test_conn_run_cancel PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_conn_exec_cancel tests/conn_exec_cancel.cpp)
+target_compile_features(test_conn_exec_cancel PUBLIC cxx_std_20)
+target_link_libraries(test_conn_exec_cancel common)
 add_test(test_conn_exec_cancel test_conn_exec_cancel)
+if (MSVC)
+    target_compile_options(test_conn_exec_cancel PRIVATE /bigobj)
+    target_compile_definitions(test_conn_exec_cancel 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)
 add_test(test_conn_echo_stress test_conn_echo_stress)
+if (MSVC)
+    target_compile_options(test_conn_echo_stress PRIVATE /bigobj)
+    target_compile_definitions(test_conn_echo_stress PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(test_request tests/request.cpp)
+target_compile_features(test_request PUBLIC cxx_std_17)
 add_test(test_request test_request)
+if (MSVC)
+    target_compile_options(test_request PRIVATE /bigobj)
+    target_compile_definitions(test_request PRIVATE _WIN32_WINNT=0x0601)
+endif()
 
 # Install
 #=======================================================================

CMakePresets.json

@@ -49,6 +49,7 @@
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_EXTENSIONS": "OFF",
         "CMAKE_CXX_FLAGS": "-Wall -Wextra -fsanitize=address",
+        "CMAKE_CXX_COMPILER": "g++-11",
         "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
         "PROJECT_BINARY_DIR": "${sourceDir}/build/dev",

benchmarks/cpp/asio/echo_server_client.cpp

@@ -14,8 +14,7 @@ using net::ip::tcp;
 using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
 using timer_type = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
 
-net::awaitable<void>
-example(boost::asio::ip::tcp::endpoint ep, std::string msg, int n)
+auto example(boost::asio::ip::tcp::endpoint ep, std::string msg, int n) -> net::awaitable<void>
 {
    try {
       auto ex = co_await net::this_coro::executor;

benchmarks/cpp/asio/echo_server_direct.cpp

@@ -33,7 +33,7 @@ awaitable_type echo(tcp_socket socket)
         std::size_t n = co_await socket.async_read_some(net::buffer(data), use_awaitable);
         co_await async_write(socket, net::buffer(data, n), use_awaitable);
      }
-  } catch (std::exception const& e) {
+  } catch (std::exception const&) {
      //std::printf("echo Exception: %s\n", e.what());
   }
 }

doc/Doxyfile.in

@@ -1250,7 +1250,7 @@ HTML_FILE_EXTENSION    = .html
 # of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_HEADER            = doc/htmlheader.html
+HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
 # generated HTML page. If the tag is left blank doxygen will generate a standard
@@ -1260,7 +1260,7 @@ HTML_HEADER            = doc/htmlheader.html
 # that doxygen normally uses.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_FOOTER            = doc/htmlfooter.html
+HTML_FOOTER            =
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
 # sheet that is used by each HTML page. It can be used to fine-tune the look of
@@ -1285,7 +1285,7 @@ HTML_STYLESHEET        =
 # list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_STYLESHEET  = doc/aedis.css
+HTML_EXTRA_STYLESHEET  = doc/doxygen-awesome.css doc/doxygen-awesome-sidebar-only.css
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
@@ -1578,7 +1578,7 @@ ECLIPSE_DOC_ID         = org.doxygen.Project
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-DISABLE_INDEX          = YES
+DISABLE_INDEX          = NO
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information. If the tag
@@ -1595,7 +1595,7 @@ DISABLE_INDEX          = YES
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-GENERATE_TREEVIEW      = NO
+GENERATE_TREEVIEW      = YES
 
 # When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
 # FULL_SIDEBAR option determines if the side bar is limited to only the treeview

doc/DoxygenLayout.xml

@@ -3,7 +3,7 @@
   <!-- Navigation index tabs for HTML output -->
   <navindex>
     <tab type="mainpage" visible="yes" title="Contents"/>
-    <tab type="pages" visible="no" title="" intro=""/>
+    <tab type="pages" visible="yes" title="" intro=""/>
     <tab type="modules" visible="no" title="Reference" intro=""/>
     <tab type="namespaces" visible="no" title="">
       <tab type="namespacelist" visible="yes" title="" intro=""/>

doc/aedis.css

@@ -1,30 +0,0 @@
-/* Doxygen HTML_EXTRA_STYLESHEET */
-
-div.contents {
-    max-width: 100em;
-    margin-right: 5em;
-    margin-left: 5em;
-}
-
-.ui-resizable-e {
-  background-image:url("splitbar.png");
-  background-size:100%;
-  background-repeat:repeat-y;
-  background-attachment: scroll;
-  cursor:ew-resize;
-  height:100%;
-  right:0;
-  top:0;
-  width:1px;
-}
-
-.pyrootbox {
-  border: 1px solid #879ecb;
-  background-color: #f9fafc;
-  padding: 15px;
-}
-
-code
-{
-    background-color:#fffbeb;
-}

doc/doxygen-awesome-sidebar-only.css

@@ -0,0 +1,115 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ */
+
+html {
+    /* side nav width. MUST be = `TREEVIEW_WIDTH`.
+     * Make sure it is wide enough to contain the page title (logo + title + version)
+     */
+    --side-nav-fixed-width: 335px;
+    --menu-display: none;
+
+    --top-height: 120px;
+    --toc-sticky-top: -25px;
+    --toc-max-height: calc(100vh - 2 * var(--spacing-medium) - 25px);
+}
+
+#projectname {
+    white-space: nowrap;
+}
+
+
+@media screen and (min-width: 768px) {
+    html {
+        --searchbar-background: var(--page-background-color);
+    }
+
+    #side-nav {
+        min-width: var(--side-nav-fixed-width);
+        max-width: var(--side-nav-fixed-width);
+        top: var(--top-height);
+        overflow: visible;
+    }
+
+    #nav-tree, #side-nav {
+        height: calc(100vh - var(--top-height)) !important;
+    }
+
+    #nav-tree {
+        padding: 0;
+    }
+
+    #top {
+        display: block;
+        border-bottom: none;
+        height: var(--top-height);
+        margin-bottom: calc(0px - var(--top-height));
+        max-width: var(--side-nav-fixed-width);
+        overflow: hidden;
+        background: var(--side-nav-background);
+    }
+    #main-nav {
+        float: left;
+        padding-right: 0;
+    }
+
+    .ui-resizable-handle {
+        cursor: default;
+        width: 1px !important;
+        box-shadow: 0 calc(-2 * var(--top-height)) 0 0 var(--separator-color);
+    }
+
+    #nav-path {
+        position: fixed;
+        right: 0;
+        left: var(--side-nav-fixed-width);
+        bottom: 0;
+        width: auto;
+    }
+
+    #doc-content {
+        height: calc(100vh - 31px) !important;
+        padding-bottom: calc(3 * var(--spacing-large));
+        padding-top: calc(var(--top-height) - 80px);
+        box-sizing: border-box;
+        margin-left: var(--side-nav-fixed-width) !important;
+    }
+
+    #MSearchBox {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)));
+    }
+
+    #MSearchField {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)) - 65px);
+    }
+
+    #MSearchResultsWindow {
+        left: var(--spacing-medium) !important;
+        right: auto;
+    }
+}

doc/htmlfooter.html

@@ -1,19 +0,0 @@
-<!-- HTML footer for doxygen 1.8.14-->
-<!-- start footer part -->
-<!--BEGIN GENERATE_TREEVIEW-->
-<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
-  <ul>
-    $navpath
-    <li class="footer">
-    Aedis 1.0.0 - Reference Guide generated on $datetime using Doxygen $doxygenversion &#160;&#160;
-    <img class="footer" src="rootlogo_s.gif" alt="root"/></li>
-  </ul>
-</div>
-<!--END GENERATE_TREEVIEW-->
-<!--BEGIN !GENERATE_TREEVIEW-->
-<hr class="footer"/><address class="footer">
-Author: Marcelo Zimbres Silva.
-</address>
-<!--END !GENERATE_TREEVIEW-->
-</body>
-</html>

doc/htmlheader.html

@@ -1,34 +0,0 @@
-<!-- HTML header for doxygen 1.8.14-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen $doxygenversion"/>
-<meta name="viewport" content="width=device-width, initial-scale=1"/>
-<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
-<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
-<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="$relpath^jquery.js"></script>
-<script type="text/javascript" src="$relpath^dynsections.js"></script>
-$search
-<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
-$extrastylesheet
-
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-
-<!--BEGIN TITLEAREA-->
-<div id="titlearea">
-<table bgcolor="#346295" cellspacing="0" cellpadding="6">
- <tbody>
- <tr>
-  <td valign="middle" style="color: #FFFFFF" nowrap="nowrap"><font size="6">$projectname $projectnumber</font> &#160; <br> $projectbrief </td>
-  <td style="width:100%"> $searchbox </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!--END TITLEAREA-->
-<!-- end header part -->

examples/chat_room.cpp

@@ -1,106 +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 <string>
-#include <iostream>
-#include "unistd.h"
-
-#include <boost/asio.hpp>
-#if defined(BOOST_ASIO_HAS_CO_AWAIT) && defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-#include <boost/asio/experimental/awaitable_operators.hpp>
-#include <aedis.hpp>
-#include "print.hpp"
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using namespace net::experimental::awaitable_operators;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::resp3::node;
-using aedis::endpoint;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using tcp_acceptor = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::acceptor>;
-using stream_descriptor = net::use_awaitable_t<>::as_default_on_t<net::posix::stream_descriptor>;
-using connection = aedis::connection<tcp_socket>;
-using stimer = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
-
-// Chat over redis pubsub. To test, run this program from different
-// terminals and type messages to stdin. Use
-//
-//    $ redis-cli monitor
-//
-// to monitor the message traffic.
-
-// Receives messages from other users.
-net::awaitable<void> push_receiver(std::shared_ptr<connection> conn)
-{
-   for (std::vector<node<std::string>> resp;;) {
-      co_await conn->async_receive(adapt(resp));
-      print_push(resp);
-      resp.clear();
-   }
-}
-
-// Subscribes to the channels when a new connection is stablished.
-net::awaitable<void> reconnect(std::shared_ptr<connection> conn)
-{
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("SUBSCRIBE", "chat-channel");
-
-   stimer timer{co_await net::this_coro::executor};
-   endpoint ep{"127.0.0.1", "6379"};
-   for (;;) {
-      boost::system::error_code ec1, ec2;
-      co_await (
-         conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) &&
-         conn->async_exec(req, adapt(), net::redirect_error(net::use_awaitable, ec2))
-      );
-      std::clog << "async_run: " << ec1.message() << "\n"
-                << "async_exec: " << ec2.message() << std::endl;
-      conn->reset_stream();
-      timer.expires_after(std::chrono::seconds{1});
-      co_await timer.async_wait();
-   }
-}
-
-// Publishes messages to other users.
-net::awaitable<void> publisher(stream_descriptor& in, std::shared_ptr<connection> conn)
-{
-   for (std::string msg;;) {
-      auto n = co_await net::async_read_until(in, net::dynamic_buffer(msg, 1024), "\n");
-      request req;
-      req.push("PUBLISH", "chat-channel", msg);
-      co_await conn->async_exec(req);
-      msg.erase(0, n);
-   }
-}
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc{1};
-      stream_descriptor in{ioc, ::dup(STDIN_FILENO)};
-
-      auto conn = std::make_shared<connection>(ioc);
-      co_spawn(ioc, publisher(in, conn), net::detached);
-      co_spawn(ioc, push_receiver(conn), net::detached);
-      co_spawn(ioc, reconnect(conn), net::detached);
-
-      net::signal_set signals(ioc, SIGINT, SIGTERM);
-      signals.async_wait([&](auto, auto){ ioc.stop(); });
-
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-
-#else // defined(BOOST_ASIO_HAS_CO_AWAIT) && defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 0;}
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT) && defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)

examples/common/aedis.cpp

@@ -0,0 +1,7 @@
+/* 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 <aedis/src.hpp>

examples/common/common.cpp

@@ -0,0 +1,93 @@
+/* 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 "common.hpp"
+
+#include <boost/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#include <iostream>
+
+namespace net = boost::asio;
+using namespace net::experimental::awaitable_operators;
+using resolver = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::resolver>;
+using timer_type = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
+using aedis::resp3::request;
+using aedis::adapt;
+using aedis::operation;
+
+namespace
+{
+auto redir(boost::system::error_code& ec)
+   { return net::redirect_error(net::use_awaitable, ec); }
+}
+
+auto healthy_checker(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   try {
+      request req;
+      req.push("PING");
+
+      timer_type timer{co_await net::this_coro::executor};
+
+      for (boost::system::error_code ec;;) {
+         timer.expires_after(std::chrono::seconds{1});
+         co_await (conn->async_exec(req, adapt()) || timer.async_wait(redir(ec)));
+
+         if (!ec) {
+            co_return;
+         }
+
+         // Waits some time before trying the next ping.
+         timer.expires_after(std::chrono::seconds{1});
+         co_await timer.async_wait();
+      }
+   } catch (...) {
+   }
+}
+
+auto
+connect(
+   std::shared_ptr<connection> conn,
+   std::string const& host,
+   std::string const& port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   resolver resv{ex};
+   timer_type timer{ex};
+
+   boost::system::error_code ec;
+   timer.expires_after(std::chrono::seconds{5});
+   auto const addrs = co_await (resv.async_resolve(host, port) || timer.async_wait(redir(ec)));
+   if (!ec)
+      throw std::runtime_error("Resolve timeout");
+
+   timer.expires_after(std::chrono::seconds{5});
+   co_await (net::async_connect(conn->next_layer(), std::get<0>(addrs)) || timer.async_wait(redir(ec)));
+   if (!ec)
+      throw std::runtime_error("Connect timeout");
+}
+
+auto run(net::awaitable<void> op) -> int
+{
+   try {
+      net::io_context ioc;
+      net::co_spawn(ioc, std::move(op), [](std::exception_ptr p) {
+         if (p)
+            std::rethrow_exception(p);
+      });
+      ioc.run();
+
+      return 0;
+
+   } catch (std::exception const& e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+   }
+
+   return 1;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/common/common.hpp

@@ -0,0 +1,34 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_EXAMPLES_COMMON_HPP
+#define AEDIS_EXAMPLES_COMMON_HPP
+
+#include <boost/asio.hpp>
+#include <aedis.hpp>
+#include <memory>
+#include <iostream>
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+using connection = boost::asio::use_awaitable_t<>::as_default_on_t<aedis::connection>;
+
+auto
+connect(
+   std::shared_ptr<connection> conn,
+   std::string const& host,
+   std::string const& port) -> boost::asio::awaitable<void>;
+
+auto healthy_checker(std::shared_ptr<connection> conn) -> boost::asio::awaitable<void>;
+
+auto run(boost::asio::awaitable<void> op) -> int;
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // AEDIS_EXAMPLES_COMMON_HPP

examples/common/main.cpp

@@ -0,0 +1,38 @@
+/* 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/asio.hpp>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+#include "common.hpp"
+
+extern boost::asio::awaitable<void> co_main(std::string, std::string);
+
+auto main(int argc, char * argv[]) -> int
+{
+   std::string host = "127.0.0.1";
+   std::string port = "6379";
+
+   if (argc == 3) {
+      host = argv[1];
+      port = argv[2];
+   }
+
+   return run(co_main(host, port));
+}
+
+#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+#include <iostream>
+
+auto main() -> int
+{
+   std::cout << "Requires coroutine support." << std::endl;
+   return 0;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/containers.cpp

@@ -1,125 +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 <map>
-#include <vector>
-#include <iostream>
-
-#include <boost/asio.hpp>
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
-#include <aedis.hpp>
-#include "print.hpp"
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using namespace net::experimental::awaitable_operators;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::endpoint;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using connection = aedis::connection<tcp_socket>;
-
-// To avoid verbosity.
-auto redir(boost::system::error_code& ec)
-{
-   return net::redirect_error(net::use_awaitable, ec);
-}
-
-// Sends some containers.
-net::awaitable<void> send(endpoint ep)
-{
-   auto ex = co_await net::this_coro::executor;
-
-   std::vector<int> vec
-      {1, 2, 3, 4, 5, 6};
-
-   std::map<std::string, std::string> map
-      {{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}};
-
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push_range("RPUSH", "rpush-key", vec); // Sends
-   req.push_range("HSET", "hset-key", map); // Sends
-   req.push("QUIT");
-
-   connection conn{ex};
-   co_await (conn.async_run(ep) || conn.async_exec(req));
-}
-
-// Retrieves a Redis hash as an std::map.
-net::awaitable<std::map<std::string, std::string>> retrieve_hashes(endpoint ep)
-{
-   connection conn{co_await net::this_coro::executor};
-
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("HGETALL", "hset-key");
-   req.push("QUIT");
-
-   std::map<std::string, std::string> ret;
-   auto resp = std::tie(ret, std::ignore);
-   co_await (conn.async_run(ep) || conn.async_exec(req, adapt(resp)));
-
-   co_return std::move(ret);
-}
-
-// Retrieves as a data structure.
-net::awaitable<void> transaction(endpoint ep)
-{
-   connection conn{co_await net::this_coro::executor};
-
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("MULTI");
-   req.push("LRANGE", "rpush-key", 0, -1); // Retrieves
-   req.push("HGETALL", "hset-key"); // Retrieves
-   req.push("EXEC");
-   req.push("QUIT");
-
-   std::tuple<
-      aedis::ignore, // multi
-      aedis::ignore, // lrange
-      aedis::ignore, // hgetall
-      std::tuple<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>>, // exec
-      aedis::ignore  // quit
-   > resp;
-
-   co_await (conn.async_run(ep) || conn.async_exec(req, adapt(resp)));
-
-   print(std::get<0>(std::get<3>(resp)).value());
-   print(std::get<1>(std::get<3>(resp)).value());
-}
-
-net::awaitable<void> async_main()
-{
-   try {
-      endpoint ep{"127.0.0.1", "6379"};
-      co_await send(ep);
-      co_await transaction(ep);
-      auto const hashes = co_await retrieve_hashes(ep);
-      print(hashes);
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc;
-      net::co_spawn(ioc, async_main(), net::detached);
-      ioc.run();
-   } catch (...) {
-      std::cerr << "Error." << std::endl;
-   }
-}
-
-#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
-auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 0;}
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp17_intro.cpp

@@ -0,0 +1,101 @@
+/* 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 <iostream>
+#include <boost/asio.hpp>
+#include <aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using aedis::resp3::request;
+using aedis::adapt;
+using aedis::operation;
+
+void log(boost::system::error_code const& ec, char const* prefix)
+{
+   std::clog << prefix << ec.message() << std::endl;
+}
+
+auto main(int argc, char * argv[]) -> int
+{
+   try {
+      std::string host = "127.0.0.1";
+      std::string port = "6379";
+
+      if (argc == 3) {
+         host = argv[1];
+         port = argv[2];
+      }
+
+      // The request
+      resp3::request req;
+      req.push("HELLO", 3);
+      req.push("PING", "Hello world");
+      req.push("QUIT");
+
+      // The response.
+      std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+      net::io_context ioc;
+
+      // IO objects.
+      net::ip::tcp::resolver resv{ioc};
+      aedis::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: ");
+         }
+
+         std::cout << "PING: " << std::get<1>(resp) << 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, adapt(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);
+
+      ioc.run();
+      return 0;
+
+   } catch (std::exception const& e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+   }
+
+   return 1;
+}
+

examples/cpp17_intro_sync.cpp

@@ -0,0 +1,79 @@
+/* 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 <tuple>
+#include <string>
+#include <thread>
+#include <iostream>
+#include <boost/asio.hpp>
+#include <aedis.hpp>
+
+// Include this in no more than one .cpp file.
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using aedis::adapt;
+using connection = aedis::connection;
+
+template <class Adapter>
+auto exec(std::shared_ptr<connection> conn, resp3::request const& req, Adapter adapter)
+{
+   net::dispatch(
+      conn->get_executor(),
+      net::deferred([&]() { return conn->async_exec(req, adapter, net::deferred); }))
+      (net::use_future).get();
+}
+
+auto logger = [](auto const& ec)
+   { std::clog << "Run: " << ec.message() << std::endl; };
+
+auto main(int argc, char * argv[]) -> int
+{
+   try {
+      std::string host = "127.0.0.1";
+      std::string port = "6379";
+
+      if (argc == 3) {
+         host = argv[1];
+         port = argv[2];
+      }
+
+      net::io_context ioc{1};
+
+      auto conn = std::make_shared<connection>(ioc);
+
+      // Resolves the address
+      net::ip::tcp::resolver resv{ioc};
+      auto const res = resv.resolve(host, port);
+
+      // Connect to Redis
+      net::connect(conn->next_layer(), res);
+
+      // 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();
+      }};
+
+      resp3::request req;
+      req.push("HELLO", 3);
+      req.push("PING");
+      req.push("QUIT");
+
+      std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+      // Executes commands synchronously.
+      exec(conn, req, adapt(resp));
+
+      std::cout << "Response: " << std::get<1>(resp) << std::endl;
+
+      t.join();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

examples/cpp17_low_level_sync.cpp

@@ -14,24 +14,29 @@
 
 namespace net = boost::asio;
 namespace resp3 = aedis::resp3;
-
-using aedis::resp3::request;
 using aedis::adapter::adapt2;
-using net::ip::tcp;
 
-int main()
+auto main(int argc, char * argv[]) -> int
 {
    try {
+      std::string host = "127.0.0.1";
+      std::string port = "6379";
+
+      if (argc == 3) {
+         host = argv[1];
+         port = argv[2];
+      }
+
       net::io_context ioc;
-      tcp::resolver resv{ioc};
-      auto const res = resv.resolve("127.0.0.1", "6379");
-      tcp::socket socket{ioc};
+      net::ip::tcp::resolver resv{ioc};
+      auto const res = resv.resolve(host, port);
+      net::ip::tcp::socket socket{ioc};
       net::connect(socket, res);
 
       // Creates the request and writes to the socket.
-      request req;
+      resp3::request req;
       req.push("HELLO", 3);
-      req.push("PING");
+      req.push("PING", "Hello world");
       req.push("QUIT");
       resp3::write(socket, req);
 

examples/cpp20_chat_room.cpp

@@ -0,0 +1,73 @@
+/* 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/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <iostream>
+namespace net = boost::asio;
+#if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#include <aedis.hpp>
+#include <unistd.h>
+
+#include "common/common.hpp"
+
+namespace resp3 = aedis::resp3;
+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 aedis::adapt;
+
+// Chat over Redis pubsub. To test, run this program from multiple
+// terminals and type messages to stdin.
+
+// Receives Redis pushes.
+auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   for (std::vector<resp3::node<std::string>> resp;;) {
+      co_await conn->async_receive(adapt(resp));
+      std::cout << resp.at(1).value << " " << resp.at(2).value << " " << resp.at(3).value << std::endl;
+      resp.clear();
+   }
+}
+
+// Publishes stdin messages to a Redis channel.
+auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   for (std::string msg;;) {
+      auto n = co_await net::async_read_until(*in, net::dynamic_buffer(msg, 1024), "\n");
+      resp3::request req;
+      req.push("PUBLISH", "chat-channel", msg);
+      co_await conn->async_exec(req);
+      msg.erase(0, n);
+   }
+}
+
+// Called from the main function (see main.cpp)
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   auto stream = std::make_shared<stream_descriptor>(ex, ::dup(STDIN_FILENO));
+   signal_set sig{ex, SIGINT, SIGTERM};
+
+   resp3::request req;
+   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) ||
+         healthy_checker(conn) || sig.async_wait()) && conn->async_exec(req));
+}
+
+#else // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   std::cout << "Requires support for posix streams." << std::endl;
+   co_return;
+}
+#endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_containers.cpp

@@ -0,0 +1,116 @@
+/* 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/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#include <aedis.hpp>
+#include <map>
+#include <vector>
+
+#include "common/common.hpp"
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using namespace net::experimental::awaitable_operators;
+using aedis::adapt;
+
+void print(std::map<std::string, std::string> const& cont)
+{
+   for (auto const& e: cont)
+      std::cout << e.first << ": " << e.second << "\n";
+}
+
+void print(std::vector<int> const& cont)
+{
+   for (auto const& e: cont) std::cout << e << " ";
+   std::cout << "\n";
+}
+
+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();
+}
+
+// Stores the content of some STL containers in Redis.
+auto store(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   std::vector<int> vec
+      {1, 2, 3, 4, 5, 6};
+
+   std::map<std::string, std::string> map
+      {{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}};
+
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push_range("RPUSH", "rpush-key", vec);
+   req.push_range("HSET", "hset-key", map);
+
+   co_await conn->async_exec(req);
+}
+
+auto hgetall(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   // A request contains multiple commands.
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push("HGETALL", "hset-key");
+
+   // Responses as tuple elements.
+   std::tuple<aedis::ignore, std::map<std::string, std::string>> resp;
+
+   // Executes the request and reads the response.
+   co_await conn->async_exec(req, adapt(resp));
+
+   print(std::get<1>(resp));
+}
+
+// Retrieves in a transaction.
+auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push("MULTI");
+   req.push("LRANGE", "rpush-key", 0, -1); // Retrieves
+   req.push("HGETALL", "hset-key"); // Retrieves
+   req.push("EXEC");
+
+   std::tuple<
+      aedis::ignore, // hello
+      aedis::ignore, // multi
+      aedis::ignore, // lrange
+      aedis::ignore, // hgetall
+      std::tuple<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>> // exec
+   > resp;
+
+   co_await conn->async_exec(req, adapt(resp));
+
+   print(std::get<0>(std::get<4>(resp)).value());
+   print(std::get<1>(std::get<4>(resp)).value());
+}
+
+auto quit(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("QUIT");
+
+   co_await conn->async_exec(req);
+}
+
+// Called from the main function (see main.cpp)
+net::awaitable<void> co_main(std::string host, std::string port)
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, run(conn, host, port), net::detached);
+   co_await store(conn);
+   co_await transaction(conn);
+   co_await hgetall(conn);
+   co_await quit(conn);
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_echo_server.cpp

@@ -0,0 +1,62 @@
+/* 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/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 tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using tcp_acceptor = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::acceptor>;
+using signal_set = net::use_awaitable_t<>::as_default_on_t<net::signal_set>;
+using aedis::adapt;
+
+auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   std::string resp;
+
+   for (std::string buffer;;) {
+      auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
+      req.push("PING", buffer);
+      auto tmp = std::tie(resp);
+      co_await conn->async_exec(req, adapt(tmp));
+      co_await net::async_write(socket, net::buffer(resp));
+      resp.clear();
+      req.clear();
+      buffer.erase(0, n);
+   }
+}
+
+// Listens for tcp connections.
+auto listener(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
+   for (;;)
+      net::co_spawn(ex, echo_server_session(co_await acc.async_accept(), conn), net::detached);
+}
+
+// Called from the main function (see main.cpp)
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   signal_set sig{ex, SIGINT, SIGTERM};
+
+   resp3::request req;
+   req.push("HELLO", 3);
+
+   co_await connect(conn, host, port);
+   co_await ((conn->async_run() || listener(conn) || healthy_checker(conn) ||
+            sig.async_wait()) && conn->async_exec(req));
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_intro.cpp

@@ -0,0 +1,61 @@
+/* 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/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <aedis.hpp>
+#include "common/common.hpp"
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using aedis::adapt;
+using aedis::operation;
+
+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();
+}
+
+auto hello(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("HELLO", 3);
+
+   co_await conn->async_exec(req);
+}
+
+auto ping(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("PING", "Hello world");
+
+   std::tuple<std::string> resp;
+   co_await conn->async_exec(req, adapt(resp));
+
+   std::cout << "PING: " << std::get<0>(resp) << std::endl;
+}
+
+auto quit(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   resp3::request req;
+   req.push("QUIT");
+
+   co_await conn->async_exec(req);
+}
+
+// Called from the main function (see main.cpp)
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, run(conn, host, port), net::detached);
+   co_await hello(conn);
+   co_await ping(conn);
+   co_await quit(conn);
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_intro_awaitable_ops.cpp

@@ -0,0 +1,35 @@
+/* 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/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 co_main(std::string host, std::string port) -> 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, host, port);
+   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)

examples/cpp20_intro_tls.cpp

@@ -0,0 +1,58 @@
+/* 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 <tuple>
+#include <string>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#include <boost/asio/ssl.hpp>
+
+#include <aedis.hpp>
+#include <aedis/ssl/connection.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using namespace net::experimental::awaitable_operators;
+using resolver = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::resolver>;
+using aedis::adapt;
+using connection = net::use_awaitable_t<>::as_default_on_t<aedis::ssl::connection>;
+
+auto verify_certificate(bool, net::ssl::verify_context&) -> bool
+{
+   std::cout << "set_verify_callback" << std::endl;
+   return true;
+}
+
+net::awaitable<void> co_main(std::string, std::string)
+{
+   resp3::request req;
+   req.push("HELLO", 3, "AUTH", "aedis", "aedis");
+   req.push("PING");
+   req.push("QUIT");
+
+   std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+   // Resolve
+   auto ex = co_await net::this_coro::executor;
+   resolver resv{ex};
+   auto const endpoints = co_await resv.async_resolve("db.occase.de", "6380");
+
+   net::ssl::context ctx{net::ssl::context::sslv23};
+   connection conn{ex, ctx};
+   conn.next_layer().set_verify_mode(net::ssl::verify_peer);
+   conn.next_layer().set_verify_callback(verify_certificate);
+
+   co_await net::async_connect(conn.lowest_layer(), endpoints);
+   co_await conn.next_layer().async_handshake(net::ssl::stream_base::client);
+   co_await (conn.async_run() || conn.async_exec(req, adapt(resp)));
+
+   std::cout << "Response: " << std::get<1>(resp) << std::endl;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_low_level_async.cpp

@@ -0,0 +1,48 @@
+/* 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/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <aedis.hpp>
+#include <string>
+#include <iostream>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using resolver = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::resolver>;
+using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using aedis::adapter::adapt2;
+using net::ip::tcp;
+
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+
+   resolver resv{ex};
+   auto const addrs = co_await resv.async_resolve(host, port);
+   tcp_socket socket{ex};
+   co_await net::async_connect(socket, addrs);
+
+   // Creates the request and writes to the socket.
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push("PING", "Hello world");
+   req.push("QUIT");
+   co_await resp3::async_write(socket, req);
+
+   // Responses
+   std::string buffer, resp;
+
+   // Reads the responses to all commands in the request.
+   auto dbuffer = net::dynamic_buffer(buffer);
+   co_await resp3::async_read(socket, dbuffer);
+   co_await resp3::async_read(socket, dbuffer, adapt2(resp));
+   co_await resp3::async_read(socket, dbuffer);
+
+   std::cout << "Ping: " << resp << std::endl;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_resolve_with_sentinel.cpp

@@ -0,0 +1,70 @@
+/* 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/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 endpoints = net::ip::tcp::resolver::results_type;
+using aedis::adapt;
+
+auto redir(boost::system::error_code& ec)
+   { return net::redirect_error(net::use_awaitable, ec); }
+
+struct address {
+   std::string host;
+   std::string port;
+};
+
+// 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& endpoints) -> net::awaitable<address>
+{
+   resp3::request req;
+   req.push("SENTINEL", "get-master-addr-by-name", "mymaster");
+   req.push("QUIT");
+
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+
+   std::tuple<std::optional<std::array<std::string, 2>>, aedis::ignore> addr;
+   for (auto ep : endpoints) {
+      boost::system::error_code ec;
+      co_await connect(conn, ep.host, ep.port);
+      co_await (conn->async_run() && conn->async_exec(req, adapt(addr), redir(ec)));
+      conn->reset_stream();
+      if (std::get<0>(addr))
+         co_return address{std::get<0>(addr).value().at(0), std::get<0>(addr).value().at(1)};
+   }
+
+   co_return address{};
+}
+
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   // A list of sentinel addresses from which only one is responsive.
+   // This simulates sentinels that are down.
+   std::vector<address> const endpoints
+   { {"foo", "26379"}
+   , {"bar", "26379"}
+   , {host, port}
+   };
+
+   auto const ep = co_await resolve_master_address(endpoints);
+
+   std::clog
+      << "Host: " << ep.host << "\n"
+      << "Port: " << ep.port << "\n"
+      << std::flush;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_serialization.cpp

@@ -0,0 +1,111 @@
+/* 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/asio.hpp>
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#include <boost/asio/experimental/awaitable_operators.hpp>
+#define BOOST_JSON_NO_LIB
+#define BOOST_CONTAINER_NO_LIB
+#include <boost/json.hpp>
+#include <aedis.hpp>
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <set>
+#include <iterator>
+#include <string>
+#include "common/common.hpp"
+
+// Include this in no more than one .cpp file.
+#include <boost/json/src.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using namespace net::experimental::awaitable_operators;
+using namespace boost::json;
+using aedis::adapt;
+
+struct user {
+   std::string name;
+   std::string age;
+   std::string country;
+
+   friend auto operator<(user const& a, user const& b)
+   {
+      return std::tie(a.name, a.age, a.country) < std::tie(b.name, b.age, b.country);
+   }
+
+   friend auto operator<<(std::ostream& os, user const& u) -> std::ostream&
+   {
+      os << "Name: " << u.name << "\n"
+         << "Age: " << u.age << "\n"
+         << "Country: " << u.country;
+
+      return os;
+   }
+};
+
+// Boost.Json serialization.
+void tag_invoke(value_from_tag, value& jv, user const& u)
+{
+   jv =
+   { {"name", u.name}
+   , {"age", u.age}
+   , {"country", u.country}
+   };
+}
+
+template<class T>
+void extract(object const& obj, T& t, std::string_view key)
+{
+   t = value_to<T>(obj.at(key));
+}
+
+auto tag_invoke(value_to_tag<user>, value const& jv)
+{
+   user u;
+   object const& obj = jv.as_object();
+   extract(obj, u.name, "name");
+   extract(obj, u.age, "age");
+   extract(obj, u.country, "country");
+   return u;
+}
+
+// Aedis serialization
+void to_bulk(std::pmr::string& to, user const& u)
+{
+   aedis::resp3::to_bulk(to, serialize(value_from(u)));
+}
+
+void from_bulk(user& u, std::string_view sv, boost::system::error_code&)
+{
+   value jv = parse(sv);
+   u = value_to<user>(jv);
+}
+
+net::awaitable<void> co_main(std::string host, std::string port)
+{
+   std::set<user> users
+      {{"Joao", "58", "Brazil"} , {"Serge", "60", "France"}};
+
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push_range("SADD", "sadd-key", users); // Sends
+   req.push("SMEMBERS", "sadd-key"); // Retrieves
+   req.push("QUIT");
+
+   std::tuple<aedis::ignore, int, std::set<user>, std::string> 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, adapt(resp)));
+
+   for (auto const& e: std::get<2>(resp))
+      std::cout << e << "\n";
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/cpp20_subscriber.cpp

@@ -0,0 +1,68 @@
+/* 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/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 steady_timer = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
+using aedis::adapt;
+
+/* This example will subscribe and read pushes indefinitely.
+ *
+ * To test send messages with redis-cli
+ *
+ *    $ redis-cli -3
+ *    127.0.0.1:6379> PUBLISH channel some-message
+ *    (integer) 3
+ *    127.0.0.1:6379>
+ *
+ * To test reconnection try, for example, to close all clients currently
+ * connected to the Redis instance
+ *
+ * $ redis-cli
+ * > CLIENT kill TYPE pubsub
+ */
+
+// Receives pushes.
+auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   using resp_type = std::vector<resp3::node<std::string>>;
+   for (resp_type resp;;) {
+      co_await conn->async_receive(adapt(resp));
+      std::cout << resp.at(1).value << " " << resp.at(2).value << " " << resp.at(3).value << std::endl;
+      resp.clear();
+   }
+}
+
+auto co_main(std::string host, std::string port) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   steady_timer timer{ex};
+
+   resp3::request req;
+   req.push("HELLO", 3);
+   req.push("SUBSCRIBE", "channel");
+
+   // The loop will reconnect on connection lost. To exit type Ctrl-C twice.
+   for (;;) {
+      co_await connect(conn, host, port);
+      co_await ((conn->async_run() || healthy_checker(conn) || receiver(conn)) && conn->async_exec(req));
+
+      conn->reset_stream();
+      timer.expires_after(std::chrono::seconds{1});
+      co_await timer.async_wait();
+   }
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/echo_server.cpp

@@ -1,87 +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 <string>
-#include <iostream>
-
-#include <boost/asio.hpp>
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <aedis.hpp>
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::endpoint;
-using executor_type = net::io_context::executor_type;
-using socket_type = net::basic_stream_socket<net::ip::tcp, executor_type>;
-using tcp_socket = net::use_awaitable_t<executor_type>::as_default_on_t<socket_type>;
-using acceptor_type = net::basic_socket_acceptor<net::ip::tcp, executor_type>;
-using tcp_acceptor = net::use_awaitable_t<executor_type>::as_default_on_t<acceptor_type>;
-using awaitable_type = net::awaitable<void, executor_type>;
-using connection = aedis::connection<tcp_socket>;
-
-awaitable_type echo_server_session(tcp_socket socket, std::shared_ptr<connection> db)
-{
-   request req;
-   std::tuple<std::string> response;
-
-   for (std::string buffer;;) {
-      auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
-      req.push("PING", buffer);
-      co_await db->async_exec(req, adapt(response));
-      co_await net::async_write(socket, net::buffer(std::get<0>(response)));
-      std::get<0>(response).clear();
-      req.clear();
-      buffer.erase(0, n);
-   }
-}
-
-awaitable_type listener(std::shared_ptr<connection> db)
-{
-   auto ex = co_await net::this_coro::executor;
-   tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
-   for (;;)
-      net::co_spawn(ex, echo_server_session(co_await acc.async_accept(), db), net::detached);
-}
-
-net::awaitable<void> reconnect(std::shared_ptr<connection> conn)
-{
-   net::steady_timer timer{co_await net::this_coro::executor};
-   endpoint ep{"127.0.0.1", "6379"};
-   for (boost::system::error_code ec1;;) {
-      co_await conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1));
-      std::clog << "async_run: " << ec1.message() << std::endl;
-      conn->reset_stream();
-      timer.expires_after(std::chrono::seconds{1});
-      co_await timer.async_wait(net::use_awaitable);
-   }
-}
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc{1};
-      auto db = std::make_shared<connection>(ioc);
-      co_spawn(ioc, reconnect(db), net::detached);
-
-      net::signal_set signals(ioc, SIGINT, SIGTERM);
-      signals.async_wait([&](auto, auto) {
-         ioc.stop();
-      });
-
-      co_spawn(ioc, listener(db), net::detached);
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-
-#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
-auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 0;}
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/intro.cpp

@@ -1,43 +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 <tuple>
-#include <string>
-#include <boost/asio.hpp>
-#include <aedis.hpp>
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-using aedis::adapt;
-using aedis::resp3::request;
-using connection = aedis::connection<>;
-
-auto const logger = [](auto ec, auto...)
-   { std::cout << ec.message() << std::endl; };
-
-auto main() -> int
-{
-   try {
-      boost::asio::io_context ioc;
-      connection conn{ioc};
-
-      request req;
-      req.get_config().cancel_on_connection_lost = true;
-      req.push("PING");
-      req.push("QUIT");
-
-      std::tuple<std::string, aedis::ignore> resp;
-      conn.async_exec(req, adapt(resp), logger);
-      conn.async_run({"127.0.0.1", "6379"}, {}, logger);
-
-      ioc.run();
-
-      std::cout << std::get<0>(resp) << std::endl;
-   } catch (...) {
-      std::cerr << "Error" << std::endl;
-   }
-}

examples/intro_sync.cpp

@@ -1,62 +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 <tuple>
-#include <string>
-#include <thread>
-#include <boost/asio.hpp>
-#include <aedis.hpp>
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::endpoint;
-using connection = aedis::connection<>;
-
-template <class Adapter>
-auto exec(connection& conn, request const& req, Adapter adapter, boost::system::error_code& ec)
-{
-   net::dispatch(
-      conn.get_executor(),
-      net::deferred([&]() { return conn.async_exec(req, adapter, net::deferred); }))
-      (net::redirect_error(net::use_future, ec)).get();
-}
-
-auto logger = [](auto const& ec)
-   { std::clog << "Run: " << ec.message() << std::endl; };
-
-int main()
-{
-   try {
-      net::io_context ioc{1};
-
-      connection conn{ioc};
-      std::thread t{[&]() {
-         conn.async_run({"127.0.0.1", "6379"}, {}, logger);
-         ioc.run();
-      }};
-
-      request req;
-      req.get_config().cancel_on_connection_lost = true;
-      req.push("PING");
-      req.push("QUIT");
-
-      boost::system::error_code ec;
-      std::tuple<std::string, aedis::ignore> resp;
-      exec(conn, req, adapt(resp), ec);
-
-      std::cout
-         << "Exec: " << ec.message() << "\n"
-         << "Response: " << std::get<0>(resp) << std::endl;
-
-      t.join();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}

examples/intro_tls.cpp

@@ -1,57 +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 <tuple>
-#include <string>
-#include <boost/asio.hpp>
-#include <boost/asio/ssl.hpp>
-#include <aedis.hpp>
-#include <aedis/ssl/connection.hpp>
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::adapt;
-using aedis::resp3::request;
-using connection = aedis::ssl::connection<net::ssl::stream<net::ip::tcp::socket>>;
-
-auto const logger = [](auto ec, auto...)
-   { std::cout << ec.message() << std::endl; };
-
-auto verify_certificate(bool, net::ssl::verify_context&) -> bool
-{
-   std::cout << "set_verify_callback" << std::endl;
-   return true;
-}
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc;
-
-      net::ssl::context ctx{net::ssl::context::sslv23};
-
-      connection conn{ioc, ctx};
-      conn.next_layer().set_verify_mode(net::ssl::verify_peer);
-      conn.next_layer().set_verify_callback(verify_certificate);
-
-      request req;
-      req.get_config().cancel_on_connection_lost = true;
-      req.push("PING");
-      req.push("QUIT");
-
-      std::tuple<std::string, aedis::ignore> resp;
-      conn.async_exec(req, adapt(resp), logger);
-      conn.async_run({"127.0.0.1", "6379"}, {}, logger);
-
-      ioc.run();
-
-      std::cout << "Response: " << std::get<0>(resp) << std::endl;
-   } catch (std::exception const& e) {
-      std::cerr << "Error: " << e.what() << std::endl;
-   }
-}

examples/print.hpp

@@ -1,65 +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 <map>
-#include <set>
-#include <vector>
-#include <string>
-#include <iostream>
-
-#include <aedis/resp3/type.hpp>
-#include <aedis/resp3/node.hpp>
-
-// Some functions to make the examples less repetitive.
-
-namespace net = boost::asio;
-using aedis::resp3::node;
-
-void print_aggr(std::vector<aedis::resp3::node<std::string>>& v)
-{
-   if (std::empty(v))
-      return;
-
-   auto const m = aedis::resp3::element_multiplicity(v.front().data_type);
-   for (auto i = 0lu; i < m * v.front().aggregate_size; ++i)
-      std::cout << v[i + 1].value << " ";
-   std::cout << "\n";
-   v.clear();
-}
-
-template <class T>
-void print(std::vector<T> const& cont)
-{
-   for (auto const& e: cont) std::cout << e << " ";
-   std::cout << "\n";
-}
-
-template <class T>
-void print(std::set<T> const& cont)
-{
-   for (auto const& e: cont) std::cout << e << "\n";
-}
-
-template <class T, class U>
-void print(std::map<T, U> const& cont)
-{
-   for (auto const& e: cont)
-      std::cout << e.first << ": " << e.second << "\n";
-}
-
-void print(std::string const& e)
-{
-   std::cout << e << std::endl;
-}
-
-void print_push(std::vector<aedis::resp3::node<std::string>>& resp)
-{
-   std::cout
-      << "Push type: "   << resp.at(1).value << "\n"
-      << "Channel: " << resp.at(2).value << "\n"
-      << "Message: " << resp.at(3).value << "\n"
-      << std::endl;
-}

examples/serialization.cpp

@@ -1,117 +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 <algorithm>
-#include <cstdint>
-#include <iostream>
-#include <set>
-#include <iterator>
-#include <string>
-#include <boost/json.hpp>
-#include <boost/json/src.hpp>
-#include <aedis.hpp>
-#include "print.hpp"
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::resp3::request;
-using aedis::adapt;
-using aedis::endpoint;
-using connection = aedis::connection<>;
-using namespace boost::json;
-
-struct user {
-   std::string name;
-   std::string age;
-   std::string country;
-};
-
-void tag_invoke(value_from_tag, value& jv, user const& u)
-{
-   jv =
-   { {"name", u.name}
-   , {"age", u.age}
-   , {"country", u.country}
-   };
-}
-
-template<class T>
-void extract(object const& obj, T& t, boost::string_view key)
-{
-    t = value_to<T>(obj.at(key));
-}
-
-auto tag_invoke(value_to_tag<user>, value const& jv)
-{
-    user u;
-    object const& obj = jv.as_object();
-    extract(obj, u.name, "name");
-    extract(obj, u.age, "age");
-    extract(obj, u.country, "country");
-    return u;
-}
-
-// Serializes
-void to_bulk(std::pmr::string& to, user const& u)
-{
-   aedis::resp3::to_bulk(to, serialize(value_from(u)));
-}
-
-// Deserializes
-void from_bulk(user& u, boost::string_view sv, boost::system::error_code&)
-{
-   value jv = parse(sv);
-   u = value_to<user>(jv);
-}
-
-auto operator<<(std::ostream& os, user const& u) -> std::ostream&
-{
-   os << "Name: " << u.name << "\n"
-      << "Age: " << u.age << "\n"
-      << "Country: " << u.country;
-
-   return os;
-}
-
-auto operator<(user const& a, user const& b)
-{
-   return std::tie(a.name, a.age, a.country) < std::tie(b.name, b.age, b.country);
-}
-
-auto const logger = [](auto ec, auto...)
-   { std::cout << ec.message() << std::endl; };
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc;
-      connection conn{ioc};
-
-      std::set<user> users
-         {{"Joao", "58", "Brazil"} , {"Serge", "60", "France"}};
-
-      request req;
-      req.get_config().cancel_on_connection_lost = true;
-      req.push("HELLO", 3);
-      req.push_range("SADD", "sadd-key", users); // Sends
-      req.push("SMEMBERS", "sadd-key"); // Retrieves
-      req.push("QUIT");
-
-      std::tuple<aedis::ignore, int, std::set<user>, std::string> resp;
-
-      endpoint ep{"127.0.0.1", "6379"};
-      conn.async_exec(req, adapt(resp),logger);
-      conn.async_run(ep, {}, logger);
-      ioc.run();
-
-      // Print
-      print(std::get<2>(resp));
-   } catch (std::exception const& e) {
-      std::cerr << "Error: " << e.what() << std::endl;
-   }
-}

examples/subscriber.cpp

@@ -1,103 +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 <string>
-#include <vector>
-#include <iostream>
-#include <tuple>
-
-#include <boost/asio.hpp>
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
-#include <aedis.hpp>
-#include "print.hpp"
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using namespace net::experimental::awaitable_operators;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::resp3::node;
-using aedis::endpoint;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using stimer = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
-using connection = aedis::connection<tcp_socket>;
-
-/* This example will subscribe and read pushes indefinitely.
- *
- * To test send messages with redis-cli
- *
- *    $ redis-cli -3
- *    127.0.0.1:6379> PUBLISH channel some-message
- *    (integer) 3
- *    127.0.0.1:6379>
- *
- * To test reconnection try, for example, to close all clients currently
- * connected to the Redis instance
- *
- * $ redis-cli
- * > CLIENT kill TYPE pubsub
- */
-
-// Receives pushes.
-net::awaitable<void> push_receiver(std::shared_ptr<connection> conn)
-{
-   for (std::vector<node<std::string>> resp;;) {
-      co_await conn->async_receive(adapt(resp));
-      print_push(resp);
-      resp.clear();
-   }
-}
-
-// See
-// - https://redis.io/docs/manual/sentinel.
-// - https://redis.io/docs/reference/sentinel-clients.
-net::awaitable<void> reconnect(std::shared_ptr<connection> conn)
-{
-   request req;
-   req.get_config().cancel_if_not_connected = false;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("SUBSCRIBE", "channel");
-
-   stimer timer{co_await net::this_coro::executor};
-   endpoint ep{"127.0.0.1", "6379"};
-   for (;;) {
-      boost::system::error_code ec1, ec2;
-      co_await (
-         conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) &&
-         conn->async_exec(req, adapt(), net::redirect_error(net::use_awaitable, ec2))
-      );
-      std::clog << "async_run: " << ec1.message() << "\n"
-                << "async_exec: " << ec2.message() << std::endl;
-      conn->reset_stream();
-      timer.expires_after(std::chrono::seconds{1});
-      co_await timer.async_wait();
-   }
-}
-
-auto main() -> int
-{
-   try {
-      net::io_context ioc;
-      auto conn = std::make_shared<connection>(ioc);
-
-      net::co_spawn(ioc, push_receiver(conn), net::detached);
-      net::co_spawn(ioc, reconnect(conn), net::detached);
-
-      net::signal_set signals(ioc, SIGINT, SIGTERM);
-      signals.async_wait([&](auto, auto){ ioc.stop(); });
-
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << "Error: " << e.what() << std::endl;
-   }
-}
-
-#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
-auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 0;}
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

examples/subscriber_sentinel.cpp

@@ -1,139 +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 <string>
-#include <vector>
-#include <iostream>
-#include <tuple>
-
-#include <boost/asio.hpp>
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
-#include <aedis.hpp>
-#include "print.hpp"
-
-// Include this in no more than one .cpp file.
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using namespace net::experimental::awaitable_operators;
-using aedis::adapt;
-using aedis::resp3::request;
-using aedis::resp3::node;
-using aedis::endpoint;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using stimer = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
-using connection = aedis::connection<tcp_socket>;
-
-auto is_valid(endpoint const& ep) noexcept -> bool
-{
-   return !std::empty(ep.host) && !std::empty(ep.port);
-}
-
-// Connects to a Redis instance over sentinel and performs failover in
-// case of disconnection, see
-// https://redis.io/docs/reference/sentinel-clients.  This example
-// assumes a sentinel and a redis server running on localhost.
-
-net::awaitable<void> receive_pushes(std::shared_ptr<connection> conn)
-{
-   for (std::vector<node<std::string>> resp;;) {
-      co_await conn->async_receive(adapt(resp));
-      print_push(resp);
-      resp.clear();
-   }
-}
-
-net::awaitable<endpoint> resolve()
-{
-   // A list of sentinel addresses from which only one is responsive
-   // to simulate sentinels that are down.
-   std::vector<endpoint> const endpoints
-   { {"foo", "26379"}
-   , {"bar", "26379"}
-   , {"127.0.0.1", "26379"}
-   };
-
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("SENTINEL", "get-master-addr-by-name", "mymaster");
-   req.push("QUIT");
-
-   connection conn{co_await net::this_coro::executor};
-
-   std::tuple<std::optional<std::array<std::string, 2>>, aedis::ignore> addr;
-   for (auto ep : endpoints) {
-      boost::system::error_code ec1, ec2;
-      co_await (
-         conn.async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) &&
-         conn.async_exec(req, adapt(addr), net::redirect_error(net::use_awaitable, ec2))
-      );
-
-      std::clog << "async_run: " << ec1.message() << "\n"
-                << "async_exec: " << ec2.message() << std::endl;
-
-      conn.reset_stream();
-      if (std::get<0>(addr))
-         break;
-   }
-
-   endpoint ep;
-   if (std::get<0>(addr)) {
-      ep.host = std::get<0>(addr).value().at(0);
-      ep.port = std::get<0>(addr).value().at(1);
-   }
-
-   co_return ep;
-}
-
-net::awaitable<void> reconnect(std::shared_ptr<connection> conn)
-{
-   request req;
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("SUBSCRIBE", "channel");
-
-   auto ex = co_await net::this_coro::executor;
-   stimer timer{ex};
-   for (;;) {
-      auto ep = co_await net::co_spawn(ex, resolve(), net::use_awaitable);
-      if (!is_valid(ep)) {
-         std::clog << "Can't resolve master name" << std::endl;
-         co_return;
-      }
-
-      boost::system::error_code ec1, ec2;
-      co_await (
-         conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) &&
-         conn->async_exec(req, adapt(), net::redirect_error(net::use_awaitable, ec2))
-      );
-
-      std::clog << "async_run: " << ec1.message() << "\n"
-                << "async_exec: " << ec2.message() << "\n"
-                << "Starting the failover." << std::endl;
-
-      timer.expires_after(std::chrono::seconds{1});
-      co_await timer.async_wait();
-   }
-}
-
-int main()
-{
-   try {
-      net::io_context ioc;
-      auto conn = std::make_shared<connection>(ioc);
-      net::co_spawn(ioc, receive_pushes(conn), net::detached);
-      net::co_spawn(ioc, reconnect(conn), net::detached);
-      net::signal_set signals(ioc, SIGINT, SIGTERM);
-      signals.async_wait([&](auto, auto){ ioc.stop(); });
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << "Error: " << e.what() << std::endl;
-   }
-}
-
-#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
-int main() {std::cout << "Requires coroutine support." << std::endl; return 0;}
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

include/aedis/adapt.hpp

@@ -7,18 +7,18 @@
 #ifndef AEDIS_ADAPT_HPP
 #define AEDIS_ADAPT_HPP
 
-#include <tuple>
-#include <limits>
-
-#include <boost/mp11.hpp>
-#include <boost/variant2.hpp>
-#include <boost/utility/string_view.hpp>
-#include <boost/system.hpp>
-
 #include <aedis/resp3/node.hpp>
 #include <aedis/adapter/adapt.hpp>
 #include <aedis/adapter/detail/response_traits.hpp>
 
+#include <boost/mp11.hpp>
+#include <boost/system.hpp>
+
+#include <tuple>
+#include <limits>
+#include <string_view>
+#include <variant>
+
 namespace aedis {
 
 /** @brief Tag used to ignore responses.
@@ -44,7 +44,7 @@ public:
 
    void
    operator()(
-      std::size_t, resp3::node<boost::string_view> const&, boost::system::error_code&) { }
+      std::size_t, resp3::node<std::string_view> const&, boost::system::error_code&) { }
 
    [[nodiscard]]
    auto get_supported_response_size() const noexcept
@@ -63,7 +63,7 @@ class static_adapter {
 private:
    static constexpr auto size = std::tuple_size<Tuple>::value;
    using adapter_tuple = boost::mp11::mp_transform<adapter::adapter_t, Tuple>;
-   using variant_type = boost::mp11::mp_rename<adapter_tuple, boost::variant2::variant>;
+   using variant_type = boost::mp11::mp_rename<adapter_tuple, std::variant>;
    using adapters_array_type = std::array<variant_type, size>;
 
    adapters_array_type adapters_;
@@ -87,10 +87,10 @@ public:
    void
    operator()(
       std::size_t i,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
-      using boost::variant2::visit;
+      using std::visit;
       // I am usure whether this should be an error or an assertion.
       BOOST_ASSERT(i < adapters_.size());
       visit([&](auto& arg){arg(nd, ec);}, adapters_.at(i));
@@ -122,7 +122,7 @@ public:
    void
    operator()(
       std::size_t,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       adapter_(nd, ec);
@@ -164,7 +164,7 @@ class wrapper {
 public:
    explicit wrapper(Adapter adapter) : adapter_{adapter} {}
 
-   void operator()(resp3::node<boost::string_view> const& node, boost::system::error_code& ec)
+   void operator()(resp3::node<std::string_view> const& node, boost::system::error_code& ec)
       { return adapter_(0, node, ec); }
 
    [[nodiscard]]
@@ -210,7 +210,7 @@ inline auto adapt(std::size_t max_read_size = (std::numeric_limits<std::size_t>:
  *  2. std::vector<node<String>>
  *
  *  The types T1, T2, etc can be any STL container, any integer type
- *  and \c std::string
+ *  and `std::string`.
  *
  *  @param t Tuple containing the responses.
  *  @param max_read_size Specifies the maximum size of the read

include/aedis/adapter/detail/adapters.hpp

@@ -7,6 +7,14 @@
 #ifndef AEDIS_ADAPTER_ADAPTERS_HPP
 #define AEDIS_ADAPTER_ADAPTERS_HPP
 
+#include <aedis/error.hpp>
+#include <aedis/resp3/type.hpp>
+#include <aedis/resp3/request.hpp>
+#include <aedis/resp3/detail/parser.hpp>
+#include <aedis/resp3/node.hpp>
+
+#include <boost/assert.hpp>
+
 #include <set>
 #include <optional>
 #include <unordered_set>
@@ -18,68 +26,40 @@
 #include <deque>
 #include <vector>
 #include <array>
-
-#include <boost/assert.hpp>
-#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/home/x3.hpp>
-#include <boost/utility/string_view.hpp>
-
-#include <aedis/error.hpp>
-#include <aedis/resp3/type.hpp>
-#include <aedis/resp3/request.hpp>
-#include <aedis/resp3/detail/parser.hpp>
-#include <aedis/resp3/node.hpp>
+#include <string_view>
+#include <charconv>
 
 namespace aedis::adapter::detail {
 
-inline
-auto parse_double(
-   char const* data,
-   std::size_t size,
-   boost::system::error_code& ec) -> double
-{
-   static constexpr boost::spirit::x3::real_parser<double> p{};
-   double ret = 0;
-   if (!parse(data, data + size, p, ret))
-      ec = error::not_a_double;
-
-   return ret;
-}
-
 // Serialization.
 
 template <class T>
-auto from_bulk(
-   T& i,
-   boost::string_view sv,
-   boost::system::error_code& ec) -> typename std::enable_if<std::is_integral<T>::value, void>::type
+auto from_bulk(T& i, std::string_view sv, boost::system::error_code& ec) -> typename std::enable_if<std::is_integral<T>::value, void>::type
 {
-   i = resp3::detail::parse_uint(sv.data(), sv.size(), ec);
+   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
+   if (res.ec != std::errc())
+      ec = error::not_a_number;
 }
 
 inline
-void from_bulk(
-   bool& t,
-   boost::string_view sv,
-   boost::system::error_code&)
+void from_bulk(bool& t, std::string_view sv, boost::system::error_code&)
 {
    t = *sv.data() == 't';
 }
 
 inline
-void from_bulk(
-   double& d,
-   boost::string_view sv,
-   boost::system::error_code& ec)
+void from_bulk(double& d, std::string_view sv, boost::system::error_code& ec)
 {
-   d = parse_double(sv.data(), sv.size(), ec);
+   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), d);
+   if (res.ec != std::errc())
+      ec = error::not_a_double;
 }
 
 template <class CharT, class Traits, class Allocator>
 void
 from_bulk(
    std::basic_string<CharT, Traits, Allocator>& s,
-   boost::string_view sv,
+   std::string_view sv,
    boost::system::error_code&)
 {
   s.append(sv.data(), sv.size());
@@ -105,7 +85,7 @@ private:
 
 public:
    explicit general_aggregate(Result* c = nullptr): result_(c) {}
-   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code&)
+   void operator()(resp3::node<std::string_view> const& n, boost::system::error_code&)
    {
       result_->push_back({n.data_type, n.aggregate_size, n.depth, std::string{std::cbegin(n.value), std::cend(n.value)}});
    }
@@ -119,7 +99,7 @@ private:
 public:
    explicit general_simple(Node* t = nullptr) : result_(t) {}
 
-   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code& ec)
+   void operator()(resp3::node<std::string_view> const& n, boost::system::error_code& ec)
    {
       result_->data_type = n.data_type;
       result_->aggregate_size = n.aggregate_size;
@@ -137,7 +117,7 @@ public:
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& n,
+      resp3::node<std::string_view> const& n,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(n.data_type, ec);
@@ -165,7 +145,7 @@ public:
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(nd.data_type, ec);
@@ -204,7 +184,7 @@ public:
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(nd.data_type, ec);
@@ -246,7 +226,7 @@ public:
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(nd.data_type, ec);
@@ -274,7 +254,7 @@ public:
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(nd.data_type, ec);
@@ -313,7 +293,7 @@ struct list_impl {
    void
    operator()(
       Result& result,
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       set_on_resp3_error(nd.data_type, ec);
@@ -388,7 +368,7 @@ public:
 
    void
    operator()(
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       BOOST_ASSERT(result_);
@@ -407,7 +387,7 @@ public:
 
    void
    operator()(
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
       if (nd.data_type == resp3::type::null)

include/aedis/adapter/detail/response_traits.hpp

@@ -7,17 +7,18 @@
 #ifndef AEDIS_ADAPTER_RESPONSE_TRAITS_HPP
 #define AEDIS_ADAPTER_RESPONSE_TRAITS_HPP
 
-#include <vector>
-#include <tuple>
-
-#include <boost/mp11.hpp>
-#include <boost/variant2.hpp>
-
 #include <aedis/error.hpp>
 #include <aedis/resp3/type.hpp>
 #include <aedis/resp3/read.hpp>
 #include <aedis/adapter/detail/adapters.hpp>
 
+#include <boost/mp11.hpp>
+
+#include <vector>
+#include <tuple>
+#include <string_view>
+#include <variant>
+
 namespace aedis::adapter::detail {
 
 using ignore = std::decay_t<decltype(std::ignore)>;
@@ -74,7 +75,7 @@ struct assigner {
   template <class T1, class T2>
   static void assign(T1& dest, T2& from)
   {
-     dest[N] = internal_adapt(std::get<N>(from));
+     dest[N].template emplace<N>(internal_adapt(std::get<N>(from)));
      assigner<N - 1>::assign(dest, from);
   }
 };
@@ -84,7 +85,7 @@ struct assigner<0> {
   template <class T1, class T2>
   static void assign(T1& dest, T2& from)
   {
-     dest[0] = internal_adapt(std::get<0>(from));
+     dest[0].template emplace<0>(internal_adapt(std::get<0>(from)));
   }
 };
 
@@ -96,7 +97,7 @@ private:
          boost::mp11::mp_rename<
             boost::mp11::mp_transform<
                adapter_t, Tuple>,
-               boost::variant2::variant>,
+               std::variant>,
          std::tuple_size<Tuple>::value>;
 
    std::size_t i_ = 0;
@@ -109,7 +110,7 @@ public:
       detail::assigner<std::tuple_size<Tuple>::value - 1>::assign(adapters_, *r);
    }
 
-   void count(resp3::node<boost::string_view> const& nd)
+   void count(resp3::node<std::string_view> const& nd)
    {
       if (nd.depth == 1) {
          if (is_aggregate(nd.data_type))
@@ -126,10 +127,10 @@ public:
 
    void
    operator()(
-      resp3::node<boost::string_view> const& nd,
+      resp3::node<std::string_view> const& nd,
       boost::system::error_code& ec)
    {
-      using boost::variant2::visit;
+      using std::visit;
 
       if (nd.depth == 0) {
          auto const real_aggr_size = nd.aggregate_size * element_multiplicity(nd.data_type);

include/aedis/connection.hpp

@@ -7,67 +7,61 @@
 #ifndef AEDIS_CONNECTION_HPP
 #define AEDIS_CONNECTION_HPP
 
-#include <chrono>
-#include <memory>
+#include <aedis/detail/connection_base.hpp>
 
 #include <boost/asio/io_context.hpp>
-#include <aedis/detail/connection_base.hpp>
+
+#include <chrono>
+#include <memory>
 
 namespace aedis {
 
 /** @brief A connection to the Redis server.
  *  @ingroup high-level-api
  *
- *  This class keeps a healthy connection to the Redis instance where
- *  commands can be sent at any time. For more details, please see the
- *  documentation of each individual function.
+ *  For more details, please see the documentation of each individual
+ *  function.
  *
  *  @tparam AsyncReadWriteStream A stream that supports reading and
  *  writing.
  */
-template <class AsyncReadWriteStream = boost::asio::ip::tcp::socket>
-class connection :
+template <class AsyncReadWriteStream>
+class basic_connection :
    private detail::connection_base<
       typename AsyncReadWriteStream::executor_type,
-      connection<AsyncReadWriteStream>> {
+      basic_connection<AsyncReadWriteStream>> {
 public:
    /// Executor type.
    using executor_type = typename AsyncReadWriteStream::executor_type;
 
    /// Type of the next layer
    using next_layer_type = AsyncReadWriteStream;
-   using base_type = detail::connection_base<executor_type, connection<AsyncReadWriteStream>>;
 
-   /** \brief Connection configuration parameters.
-    */
-   struct timeouts {
-      /// Timeout of the resolve operation.
-      std::chrono::steady_clock::duration resolve_timeout = std::chrono::seconds{10};
-
-      /// Timeout of the connect operation.
-      std::chrono::steady_clock::duration connect_timeout = std::chrono::seconds{10};
-
-      /// Timeout of the resp3-handshake operation.
-      std::chrono::steady_clock::duration resp3_handshake_timeout = std::chrono::seconds{2};
-
-      /// Time interval with which PING commands are sent to Redis.
-      std::chrono::steady_clock::duration ping_interval = std::chrono::seconds{1};
+   /// Rebinds the socket type to another executor.
+   template <class Executor1>
+   struct rebind_executor
+   {
+      /// The socket type when rebound to the specified executor.
+      using other = basic_connection<typename next_layer_type::template rebind_executor<Executor1>::other>;
    };
 
-   /// Constructor
+   using base_type = detail::connection_base<executor_type, basic_connection<AsyncReadWriteStream>>;
+
+   /// Contructs from an executor.
    explicit
-   connection(
+   basic_connection(
       executor_type ex,
       std::pmr::memory_resource* resource = std::pmr::get_default_resource())
    : base_type{ex, resource}
    , stream_{ex}
    {}
 
+   /// Contructs from a context.
    explicit
-   connection(
+   basic_connection(
       boost::asio::io_context& ioc,
       std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : connection(ioc.get_executor(), resource)
+   : basic_connection(ioc.get_executor(), resource)
    { }
 
    /// Returns the associated executor.
@@ -89,46 +83,13 @@ public:
    /// Returns a const reference to the next layer.
    auto next_layer() const noexcept -> auto const& { return stream_; }
 
-   /** @brief Establishes a connection with the Redis server asynchronously.
+   /** @brief Starts read and write operations
     *
-    *  This function performs the following steps
+    *  This function starts read and write operations with the Redis
+    *  server. More specifically it will trigger the write of all
+    *  requests i.e. calls to `async_exec` that happened prior to this
+    *  call.
     *
-    *  @li Resolves the Redis host as of `async_resolve` with the
-    *  timeout passed in the base class `connection::timeouts::resolve_timeout`.
-    *
-    *  @li Connects to one of the endpoints returned by the resolve
-    *  operation with the timeout passed in the base class
-    *  `connection::timeouts::connect_timeout`.
-    *
-    *  @li Performs a RESP3 handshake by sending a
-    *  [HELLO](https://redis.io/commands/hello/) command with protocol
-    *  version 3 and the credentials contained in the
-    *  `aedis::endpoint` object.  The timeout used is the one specified
-    *  in `connection::timeouts::resp3_handshake_timeout`.
-    *
-    *  @li Erases any password that may be contained in
-    *  `endpoint::password`.
-    *
-    *  @li Checks whether the server role corresponds to the one
-    *  specified in the `endpoint`. If `endpoint::role` is left empty,
-    *  no check is performed. If the role is different than the
-    *  expected `async_run` will complete with
-    *  `error::unexpected_server_role`.
-    *
-    *  @li Starts healthy checks with a timeout twice the value of
-    *  `connection::timeouts::ping_interval`. If no data is received during that
-    *  time interval `connection::async_run` completes with
-    *  `error::idle_timeout`.
-    *
-    *  @li Starts the healthy check operation that sends the
-    *  [PING](https://redis.io/commands/ping/) to Redis with a
-    *  frequency equal to `connection::timeouts::ping_interval`.
-    *
-    *  @li Starts reading from the socket and executes all requests
-    *  that have been started prior to this function call.
-    *
-    *  @param ep Redis endpoint.
-    *  @param ts Timeouts used by the operations.
     *  @param token Completion token.
     *
     *  The completion token must have the following signature
@@ -137,34 +98,30 @@ public:
     *  void f(boost::system::error_code);
     *  @endcode
     *
-    *  This function will complete when the connection is lost as
-    *  follows. If the error is boost::asio::error::eof this function
-    *  will complete without error.
+    *  This function will complete when the connection is lost. If the
+    *  error is boost::asio::error::eof this function will complete
+    *  without error.
     */
    template <class CompletionToken = boost::asio::default_completion_token_t<executor_type>>
-   auto
-   async_run(
-      endpoint ep,
-      timeouts ts = timeouts{},
-      CompletionToken token = CompletionToken{})
+   auto async_run(CompletionToken token = CompletionToken{})
    {
-      return base_type::async_run(ep, ts, std::move(token));
+      return base_type::async_run(std::move(token));
    }
 
    /** @brief Executes a command on the Redis server asynchronously.
     *
-    *  This function will send a request to the Redis server and
-    *  complete when the response arrives. If the request contains
-    *  only commands that don't expect a response, the completion
-    *  occurs after it has been written to the underlying stream.
-    *  Multiple concurrent calls to this function will be
+    *  This function sends a request to the Redis server and
+    *  complete after the response has been processed. If the request
+    *  contains only commands that don't expect a response, the
+    *  completion occurs after it has been written to the underlying
+    *  stream.  Multiple concurrent calls to this function will be
     *  automatically queued by the implementation.
     *
     *  @param req Request object.
     *  @param adapter Response adapter.
     *  @param token Asio completion token.
     *
-    *  For an example see echo_server.cpp. The completion token must
+    *  For an example see cpp20_echo_server.cpp. The completion token must
     *  have the following signature
     *
     *  @code
@@ -189,12 +146,12 @@ public:
     *
     *  Users that expect server pushes should call this function in a
     *  loop. If a push arrives and there is no reader, the connection
-    *  will hang and eventually timeout.
+    *  will hang.
     *
     *  @param adapter The response adapter.
     *  @param token The Asio completion token.
     *
-    *  For an example see subscriber.cpp. The completion token must
+    *  For an example see cpp20_subscriber.cpp. The completion token must
     *  have the following signature
     *
     *  @code
@@ -222,12 +179,7 @@ public:
     *  @li operation::run: Cancels the `async_run` operation. Notice
     *  that the preferred way to close a connection is to send a
     *  [QUIT](https://redis.io/commands/quit/) command to the server.
-    *  An unresponsive Redis server will also cause the idle-checks to
-    *  timeout and lead to `connection::async_run` completing with
-    *  `error::idle_timeout`.  Calling `cancel(operation::run)`
-    *  directly should be seen as the last option.
-    *  @li operation::receive: Cancels any ongoing callto
-    *  `async_receive`.
+    *  @li operation::receive: Cancels any ongoing calls to *  `async_receive`.
     *
     *  @param op: The operation to be cancelled.
     *  @returns The number of operations that have been canceled.
@@ -236,33 +188,14 @@ public:
       { return base_type::cancel(op); }
 
 private:
-   using this_type = connection<next_layer_type>;
+   using this_type = basic_connection<next_layer_type>;
 
    template <class, class> friend class detail::connection_base;
    template <class, class> friend struct detail::exec_read_op;
    template <class, class> friend struct detail::exec_op;
-   template <class, class> friend struct detail::receive_op;
-   template <class> friend struct detail::check_idle_op;
    template <class> friend struct detail::reader_op;
    template <class> friend struct detail::writer_op;
-   template <class, class> friend struct detail::connect_with_timeout_op;
-   template <class, class> friend struct detail::run_op;
-   template <class> friend struct detail::ping_op;
-
-   template <class Timer, class CompletionToken>
-   auto
-   async_connect(
-      boost::asio::ip::tcp::resolver::results_type const& endpoints,
-      timeouts ts,
-      Timer& timer,
-      CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::connect_with_timeout_op<this_type, Timer>{this, &endpoints, ts, &timer},
-               token, stream_);
-   }
+   template <class> friend struct detail::run_op;
 
    void close() { stream_.close(); }
    auto is_open() const noexcept { return stream_.is_open(); }
@@ -271,6 +204,11 @@ private:
    AsyncReadWriteStream stream_;
 };
 
+/** \brief A connection that uses a boost::asio::ip::tcp::socket.
+ *  \ingroup high-level-api
+ */
+using connection = basic_connection<boost::asio::ip::tcp::socket>;
+
 } // aedis
 
 #endif // AEDIS_CONNECTION_HPP

include/aedis/detail/connection_base.hpp

@@ -7,6 +7,18 @@
 #ifndef AEDIS_CONNECTION_BASE_HPP
 #define AEDIS_CONNECTION_BASE_HPP
 
+#include <aedis/adapt.hpp>
+#include <aedis/operation.hpp>
+#include <aedis/resp3/request.hpp>
+#include <aedis/detail/connection_ops.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/experimental/channel.hpp>
+
 #include <vector>
 #include <queue>
 #include <limits>
@@ -15,18 +27,6 @@
 #include <type_traits>
 #include <memory_resource>
 
-#include <boost/assert.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/experimental/channel.hpp>
-
-#include <aedis/adapt.hpp>
-#include <aedis/operation.hpp>
-#include <aedis/endpoint.hpp>
-#include <aedis/resp3/request.hpp>
-#include <aedis/detail/connection_ops.hpp>
-
 namespace aedis::detail {
 
 /** Base class for high level Redis asynchronous connections.
@@ -44,24 +44,19 @@ public:
    using executor_type = Executor;
    using this_type = connection_base<Executor, Derived>;
 
-   explicit
    connection_base(executor_type ex, std::pmr::memory_resource* resource)
-   : resv_{ex}
-   , ping_timer_{ex}
-   , check_idle_timer_{ex}
-   , writer_timer_{ex}
+   : writer_timer_{ex}
    , read_timer_{ex}
-   , push_channel_{ex}
+   , guarded_op_{ex}
+   , read_buffer_{resource}
+   , write_buffer_{resource}
    , reqs_{resource}
-   , last_data_{std::chrono::time_point<std::chrono::steady_clock>::min()}
    {
-      req_.get_config().cancel_if_not_connected = true;
-      req_.get_config().cancel_on_connection_lost = true;
       writer_timer_.expires_at(std::chrono::steady_clock::time_point::max());
       read_timer_.expires_at(std::chrono::steady_clock::time_point::max());
    }
 
-   auto get_executor() {return resv_.get_executor();}
+   auto get_executor() {return writer_timer_.get_executor();}
 
    auto cancel(operation op) -> std::size_t
    {
@@ -72,20 +67,16 @@ public:
          }
          case operation::run:
          {
-            resv_.cancel();
             derived().close();
-
             read_timer_.cancel();
-            check_idle_timer_.cancel();
             writer_timer_.cancel();
-            ping_timer_.cancel();
             cancel_on_conn_lost();
 
             return 1U;
          }
          case operation::receive:
          {
-            push_channel_.cancel();
+            guarded_op_.cancel();
             return 1U;
          }
          default: BOOST_ASSERT(false); return 0;
@@ -114,14 +105,16 @@ public:
 
    auto cancel_on_conn_lost() -> std::size_t
    {
+      // Must return false if the request should be removed.
       auto cond = [](auto const& ptr)
       {
          BOOST_ASSERT(ptr != nullptr);
 
-         if (ptr->get_request().get_config().cancel_on_connection_lost)
-            return false;
-
-         return !(!ptr->get_request().get_config().retry && ptr->is_written());
+         if (ptr->is_written()) {
+            return !ptr->get_request().get_config().cancel_if_unresponded;
+         } else {
+            return !ptr->get_request().get_config().cancel_on_connection_lost;
+         }
       };
 
       auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), cond);
@@ -136,57 +129,44 @@ public:
       std::for_each(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
          return ptr->reset_status();
       });
+
       return ret;
    }
 
-   template <
-      class Adapter = detail::response_traits<void>::adapter_type,
-      class CompletionToken = boost::asio::default_completion_token_t<executor_type>>
-   auto async_exec(
-      resp3::request const& req,
-      Adapter adapter = adapt(),
-      CompletionToken token = CompletionToken{})
+   template <class Adapter, class CompletionToken>
+   auto async_exec(resp3::request const& req, Adapter adapter, CompletionToken token)
    {
       BOOST_ASSERT_MSG(req.size() <= adapter.get_supported_response_size(), "Request and adapter have incompatible sizes.");
 
       return boost::asio::async_compose
          < CompletionToken
          , void(boost::system::error_code, std::size_t)
-         >(detail::exec_op<Derived, Adapter>{&derived(), &req, adapter}, token, resv_);
+         >(detail::exec_op<Derived, Adapter>{&derived(), &req, adapter}, token, writer_timer_);
    }
 
-   template <
-      class Adapter = detail::response_traits<void>::adapter_type,
-      class CompletionToken = boost::asio::default_completion_token_t<executor_type>>
-   auto async_receive(
-      Adapter adapter = adapt(),
-      CompletionToken token = CompletionToken{})
+   template <class Adapter, class CompletionToken>
+   auto async_receive(Adapter adapter, CompletionToken token)
    {
       auto f = detail::make_adapter_wrapper(adapter);
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code, std::size_t)
-         >(detail::receive_op<Derived, decltype(f)>{&derived(), f}, token, resv_);
+
+      return guarded_op_.async_wait(
+         resp3::async_read(derived().next_layer(), make_dynamic_buffer(adapter.get_max_read_size(0)), f, boost::asio::deferred),
+         std::move(token));
    }
 
-   template <class Timeouts, class CompletionToken>
-   auto
-   async_run(endpoint ep, Timeouts ts, CompletionToken token)
+   template <class CompletionToken>
+   auto async_run(CompletionToken token)
    {
-      ep_ = std::move(ep);
       return boost::asio::async_compose
          < CompletionToken
          , void(boost::system::error_code)
-         >(detail::run_op<Derived, Timeouts>{&derived(), ts}, token, resv_);
+         >(detail::run_op<Derived>{&derived()}, token, writer_timer_);
    }
 
 private:
    using clock_type = std::chrono::steady_clock;
    using clock_traits_type = boost::asio::wait_traits<clock_type>;
    using timer_type = boost::asio::basic_waitable_timer<clock_type, clock_traits_type, executor_type>;
-   using resolver_type = boost::asio::ip::basic_resolver<boost::asio::ip::tcp, executor_type>;
-   using push_channel_type = boost::asio::experimental::channel<executor_type, void(boost::system::error_code, std::size_t)>;
-   using time_point_type = std::chrono::time_point<std::chrono::steady_clock>;
 
    auto derived() -> Derived& { return static_cast<Derived&>(*this); }
 
@@ -257,8 +237,8 @@ private:
       [[nodiscard]] auto get_request() const noexcept -> auto const&
          { return *req_; }
 
-      [[nodiscard]] auto get_action() const noexcept
-         { return action_;}
+      [[nodiscard]] auto stop_requested() const noexcept
+         { return action_ == action::stop;}
 
       template <class CompletionToken>
       auto async_wait(CompletionToken token)
@@ -287,16 +267,11 @@ private:
 
    using reqs_type = std::pmr::deque<std::shared_ptr<req_info>>;
 
-   template <class, class> friend struct detail::receive_op;
    template <class> friend struct detail::reader_op;
    template <class> friend struct detail::writer_op;
-   template <class> friend struct detail::ping_op;
-   template <class, class> friend struct detail::run_op;
+   template <class> friend struct detail::run_op;
    template <class, class> friend struct detail::exec_op;
    template <class, class> friend struct detail::exec_read_op;
-   template <class> friend struct detail::resolve_with_timeout_op;
-   template <class> friend struct detail::check_idle_op;
-   template <class, class> friend struct detail::start_op;
    template <class> friend struct detail::send_receive_op;
 
    void cancel_push_requests()
@@ -315,6 +290,15 @@ private:
    void add_request_info(std::shared_ptr<req_info> const& info)
    {
       reqs_.push_back(info);
+
+      if (info->get_request().has_hello_priority()) {
+         auto rend = std::partition_point(std::rbegin(reqs_), std::rend(reqs_), [](auto const& e) {
+               return !e->is_written() && !e->is_staged();
+         });
+
+         std::rotate(std::rbegin(reqs_), std::rbegin(reqs_) + 1, rend);
+      }
+
       if (derived().is_open() && cmds_ == 0 && write_buffer_.empty())
          writer_timer_.cancel();
    }
@@ -322,26 +306,13 @@ private:
    auto make_dynamic_buffer(std::size_t max_read_size = 512)
       { return boost::asio::dynamic_buffer(read_buffer_, max_read_size); }
 
-   template <class CompletionToken>
-   auto
-   async_resolve_with_timeout(
-      std::chrono::steady_clock::duration d,
-      CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::resolve_with_timeout_op<this_type>{this, d},
-            token, resv_);
-   }
-
    template <class CompletionToken>
    auto reader(CompletionToken&& token)
    {
       return boost::asio::async_compose
          < CompletionToken
          , void(boost::system::error_code)
-         >(detail::reader_op<Derived>{&derived()}, token, resv_.get_executor());
+         >(detail::reader_op<Derived>{&derived()}, token, writer_timer_);
    }
 
    template <class CompletionToken>
@@ -350,42 +321,7 @@ private:
       return boost::asio::async_compose
          < CompletionToken
          , void(boost::system::error_code)
-         >(detail::writer_op<Derived>{&derived()}, token, resv_.get_executor());
-   }
-
-   template <
-      class Timeouts,
-      class CompletionToken>
-   auto async_start(Timeouts ts, CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::start_op<this_type, Timeouts>{this, ts}, token, resv_);
-   }
-
-   template <class CompletionToken>
-   auto
-   async_ping(
-      std::chrono::steady_clock::duration d,
-      CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::ping_op<Derived>{&derived(), d}, token, resv_);
-   }
-
-   template <class CompletionToken>
-   auto
-   async_check_idle(
-      std::chrono::steady_clock::duration d,
-      CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::check_idle_op<Derived>{&derived(), d}, token, check_idle_timer_);
+         >(detail::writer_op<Derived>{&derived()}, token, writer_timer_);
    }
 
    template <class Adapter, class CompletionToken>
@@ -394,7 +330,7 @@ private:
       return boost::asio::async_compose
          < CompletionToken
          , void(boost::system::error_code, std::size_t)
-         >(detail::exec_read_op<Derived, Adapter>{&derived(), adapter, cmds}, token, resv_);
+         >(detail::exec_read_op<Derived, Adapter>{&derived(), adapter, cmds}, token, writer_timer_);
    }
 
    void stage_request(req_info& ri)
@@ -422,57 +358,17 @@ private:
       }
    }
 
-   void prepare_hello(endpoint const& ep)
-   {
-      req_.clear();
-      if (requires_auth(ep)) {
-         req_.push("HELLO", "3", "AUTH", ep.username, ep.password);
-      } else {
-         req_.push("HELLO", "3");
-      }
-   }
-
-   auto expect_role(std::string const& expected) -> bool
-   {
-      if (std::empty(expected))
-         return true;
-
-      resp3::node<std::string> role_node;
-      role_node.data_type = resp3::type::blob_string;
-      role_node.aggregate_size = 1;
-      role_node.depth = 1;
-      role_node.value = "role";
-
-      auto iter = std::find(std::cbegin(response_), std::cend(response_), role_node);
-      if (iter == std::end(response_))
-         return false;
-
-      ++iter;
-      BOOST_ASSERT(iter != std::cend(response_));
-      return iter->value == expected;
-   }
-
-   // IO objects
-   resolver_type resv_;
-   timer_type ping_timer_;
-   timer_type check_idle_timer_;
+   // Notice we use a timer to simulate a condition-variable. It is
+   // also more suitable than a channel and the notify operation does
+   // not suspend.
    timer_type writer_timer_;
    timer_type read_timer_;
-   push_channel_type push_channel_;
+   detail::guarded_operation<executor_type> guarded_op_;
 
-   std::string read_buffer_;
-   std::string write_buffer_;
+   std::pmr::string read_buffer_;
+   std::pmr::string write_buffer_;
    std::size_t cmds_ = 0;
    reqs_type reqs_;
-
-   // Last time we received data.
-   time_point_type last_data_;
-
-   resp3::request req_;
-   std::vector<resp3::node<std::string>> response_;
-   endpoint ep_;
-   // The result of async_resolve.
-   boost::asio::ip::tcp::resolver::results_type endpoints_;
 };
 
 } // aedis

include/aedis/detail/connection_ops.hpp

@@ -7,8 +7,14 @@
 #ifndef AEDIS_CONNECTION_OPS_HPP
 #define AEDIS_CONNECTION_OPS_HPP
 
-#include <array>
-#include <algorithm>
+#include <aedis/adapt.hpp>
+#include <aedis/error.hpp>
+#include <aedis/detail/guarded_operation.hpp>
+#include <aedis/resp3/type.hpp>
+#include <aedis/resp3/detail/parser.hpp>
+#include <aedis/resp3/read.hpp>
+#include <aedis/resp3/write.hpp>
+#include <aedis/resp3/request.hpp>
 
 #include <boost/assert.hpp>
 #include <boost/system.hpp>
@@ -16,108 +22,12 @@
 #include <boost/core/ignore_unused.hpp>
 #include <boost/asio/experimental/parallel_group.hpp>
 
-#include <aedis/adapt.hpp>
-#include <aedis/error.hpp>
-#include <aedis/detail/net.hpp>
-#include <aedis/resp3/type.hpp>
-#include <aedis/resp3/detail/exec.hpp>
-#include <aedis/resp3/detail/parser.hpp>
-#include <aedis/resp3/read.hpp>
-#include <aedis/resp3/write.hpp>
-#include <aedis/resp3/request.hpp>
-
-#include <boost/asio/yield.hpp>
+#include <array>
+#include <algorithm>
+#include <string_view>
 
 namespace aedis::detail {
 
-template <class Conn, class Timer>
-struct connect_with_timeout_op {
-   Conn* conn = nullptr;
-   boost::asio::ip::tcp::resolver::results_type const* endpoints = nullptr;
-   typename Conn::timeouts ts;
-   Timer* timer = nullptr;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , boost::asio::ip::tcp::endpoint const& = {})
-   {
-      reenter (coro)
-      {
-         timer->expires_after(ts.connect_timeout);
-         yield detail::async_connect(conn->next_layer(), *timer, *endpoints, std::move(self));
-         AEDIS_CHECK_OP0();
-         self.complete({});
-      }
-   }
-};
-
-template <class Conn>
-struct resolve_with_timeout_op {
-   Conn* conn = nullptr;
-   std::chrono::steady_clock::duration resolve_timeout{};
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , boost::asio::ip::tcp::resolver::results_type const& res = {})
-   {
-      reenter (coro)
-      {
-         conn->ping_timer_.expires_after(resolve_timeout);
-         yield
-         aedis::detail::async_resolve(
-            conn->resv_, conn->ping_timer_,
-            conn->ep_.host, conn->ep_.port, std::move(self));
-         AEDIS_CHECK_OP0();
-         conn->endpoints_ = res;
-         self.complete({});
-      }
-   }
-};
-
-template <class Conn, class Adapter>
-struct receive_op {
-   Conn* conn = nullptr;
-   Adapter adapter;
-   std::size_t read_size = 0;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void
-   operator()( Self& self
-             , boost::system::error_code ec = {}
-             , std::size_t n = 0)
-   {
-      reenter (coro)
-      {
-         yield conn->push_channel_.async_receive(std::move(self));
-         AEDIS_CHECK_OP1();
-
-         yield
-         resp3::async_read(
-            conn->next_layer(),
-            conn->make_dynamic_buffer(adapter.get_max_read_size(0)),
-            adapter, std::move(self));
-
-         // cancel(receive) is needed to cancel the channel, otherwise
-         // the read operation will be blocked forever see
-         // test_push_adapter.
-         AEDIS_CHECK_OP1(conn->cancel(operation::run); conn->cancel(operation::receive));
-
-         read_size = n;
-
-         yield conn->push_channel_.async_send({}, 0, std::move(self));
-         AEDIS_CHECK_OP1();
-
-         self.complete({}, read_size);
-         return;
-      }
-   }
-};
-
 template <class Conn, class Adapter>
 struct exec_read_op {
    Conn* conn;
@@ -133,7 +43,7 @@ struct exec_read_op {
              , boost::system::error_code ec = {}
              , std::size_t n = 0)
    {
-      reenter (coro)
+      BOOST_ASIO_CORO_REENTER (coro)
       {
          // Loop reading the responses to this request.
          BOOST_ASSERT(!conn->reqs_.empty());
@@ -145,34 +55,34 @@ struct exec_read_op {
             // to hand it to the push consumer. To do that we need
             // some data in the read bufer.
             if (conn->read_buffer_.empty()) {
-               yield
+               BOOST_ASIO_CORO_YIELD
                boost::asio::async_read_until(
                   conn->next_layer(),
                   conn->make_dynamic_buffer(),
                   "\r\n", std::move(self));
-               AEDIS_CHECK_OP1(conn->cancel(operation::run));
+               AEDIS_CHECK_OP1(conn->cancel(operation::run););
             }
 
             // If the next request is a push we have to handle it to
             // the receive_op wait for it to be done and continue.
             if (resp3::to_type(conn->read_buffer_.front()) == resp3::type::push) {
-               yield
-               async_send_receive(conn->push_channel_, std::move(self));
-               AEDIS_CHECK_OP1(conn->cancel(operation::run));
+               BOOST_ASIO_CORO_YIELD
+               conn->guarded_op_.async_run(std::move(self));
+               AEDIS_CHECK_OP1(conn->cancel(operation::run););
                continue;
             }
             //-----------------------------------
 
-            yield
+            BOOST_ASIO_CORO_YIELD
             resp3::async_read(
                conn->next_layer(),
                conn->make_dynamic_buffer(adapter.get_max_read_size(index)),
-                  [i = index, adpt = adapter] (resp3::node<boost::string_view> const& nd, boost::system::error_code& ec) mutable { adpt(i, nd, ec); },
+                  [i = index, adpt = adapter] (resp3::node<std::string_view> const& nd, boost::system::error_code& ec) mutable { adpt(i, nd, ec); },
                   std::move(self));
 
             ++index;
 
-            AEDIS_CHECK_OP1(conn->cancel(operation::run));
+            AEDIS_CHECK_OP1(conn->cancel(operation::run););
 
             read_size += n;
 
@@ -205,33 +115,44 @@ struct exec_op {
              , boost::system::error_code ec = {}
              , std::size_t n = 0)
    {
-      reenter (coro)
+      BOOST_ASIO_CORO_REENTER (coro)
       {
          // Check whether the user wants to wait for the connection to
          // be stablished.
-         // TODO: is_open below reflects only whether a TCP connection
-         // has been stablished. We need a variable that informs
-         // whether HELLO was successfull and we are connected with
-         // Redis.
-         if (req->get_config().cancel_if_not_connected && !conn->is_open())
+         if (req->get_config().cancel_if_not_connected && !conn->is_open()) {
             return self.complete(error::not_connected, 0);
+         }
 
-         info = std::allocate_shared<req_info_type>(boost::asio::get_associated_allocator(self), *req, conn->resv_.get_executor());
+         info = std::allocate_shared<req_info_type>(boost::asio::get_associated_allocator(self), *req, conn->get_executor());
 
          conn->add_request_info(info);
 EXEC_OP_WAIT:
-         yield info->async_wait(std::move(self));
+         BOOST_ASIO_CORO_YIELD
+         info->async_wait(std::move(self));
          BOOST_ASSERT(ec == boost::asio::error::operation_aborted);
 
-         if (info->get_action() == Conn::req_info::action::stop) {
+         if (info->stop_requested()) {
+            // Don't have to call remove_request as it has already
+            // been by cancel(exec).
             return self.complete(ec, 0);
          }
 
          if (is_cancelled(self)) {
             if (info->is_written()) {
-               self.get_cancellation_state().clear();
-               goto EXEC_OP_WAIT; // Too late, can't cancel.
+               using c_t = boost::asio::cancellation_type;
+               auto const c = self.get_cancellation_state().cancelled();
+               if ((c & c_t::terminal) != c_t::none) {
+                  // Cancellation requires closing the connection
+                  // otherwise it stays in inconsistent state.
+                  conn->cancel(operation::run);
+                  return self.complete(ec, 0);
+               } else {
+                  // Can't implement other cancelation types, ignoring.
+                  self.get_cancellation_state().clear();
+                  goto EXEC_OP_WAIT;
+               }
             } else {
+               // Cancelation can be honored.
                conn->remove_request(info);
                self.complete(ec, 0);
                return;
@@ -240,15 +161,18 @@ EXEC_OP_WAIT:
 
          BOOST_ASSERT(conn->is_open());
           
-         if (req->size() == 0)
+         if (req->size() == 0) {
+            // Don't have to call remove_request as it has already
+            // been removed.
             return self.complete({}, 0);
+         }
 
          BOOST_ASSERT(!conn->reqs_.empty());
          BOOST_ASSERT(conn->reqs_.front() != nullptr);
          BOOST_ASSERT(conn->cmds_ != 0);
-         yield
+         BOOST_ASIO_CORO_YIELD
          conn->async_exec_read(adapter, conn->reqs_.front()->get_number_of_commands(), std::move(self));
-         AEDIS_CHECK_OP1();
+         AEDIS_CHECK_OP1(;);
 
          read_size = n;
 
@@ -270,94 +194,25 @@ EXEC_OP_WAIT:
 };
 
 template <class Conn>
-struct ping_op {
-   Conn* conn{};
-   std::chrono::steady_clock::duration ping_interval{};
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void
-   operator()( Self& self
-             , boost::system::error_code ec = {}
-             , std::size_t = 0)
-   {
-      reenter (coro) for (;;)
-      {
-         conn->ping_timer_.expires_after(ping_interval);
-         yield conn->ping_timer_.async_wait(std::move(self));
-         if (!conn->is_open() || ec || is_cancelled(self)) {
-            // Checking for is_open is necessary becuse the timer can
-            // complete with success although cancel has been called.
-            self.complete({});
-            return;
-         }
-
-         conn->req_.clear();
-         conn->req_.push("PING");
-         yield conn->async_exec(conn->req_, adapt(), std::move(self));
-         if (!conn->is_open() || is_cancelled(self)) {
-            // Checking for is_open is necessary to avoid
-            // looping back on the timer although cancel has been
-            // called.
-            return self.complete({});
-         }
-      }
-   }
-};
-
-template <class Conn>
-struct check_idle_op {
-   Conn* conn{};
-   std::chrono::steady_clock::duration ping_interval{};
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()(Self& self, boost::system::error_code ec = {})
-   {
-      reenter (coro) for (;;)
-      {
-         conn->check_idle_timer_.expires_after(2 * ping_interval);
-         yield conn->check_idle_timer_.async_wait(std::move(self));
-         if (!conn->is_open() || ec || is_cancelled(self)) {
-            // Checking for is_open is necessary becuse the timer can
-            // complete with success although cancel has been called.
-            return self.complete({});
-         }
-
-         auto const now = std::chrono::steady_clock::now();
-         if (conn->last_data_ +  (2 * ping_interval) < now) {
-            conn->cancel(operation::run);
-            self.complete(error::idle_timeout);
-            return;
-         }
-
-         conn->last_data_ = now;
-      }
-   }
-};
-
-template <class Conn, class Timeouts>
-struct start_op {
-   Conn* conn;
-   Timeouts ts;
+struct run_op {
+   Conn* conn = nullptr;
    boost::asio::coroutine coro{};
 
    template <class Self>
    void operator()( Self& self
-                  , std::array<std::size_t, 4> order = {}
+                  , std::array<std::size_t, 2> order = {}
                   , boost::system::error_code ec0 = {}
-                  , boost::system::error_code ec1 = {}
-                  , boost::system::error_code ec2 = {}
-                  , boost::system::error_code ec3 = {})
+                  , boost::system::error_code ec1 = {})
    {
-      reenter (coro)
+      BOOST_ASIO_CORO_REENTER (coro)
       {
-         yield
+         conn->write_buffer_.clear();
+         conn->cmds_ = 0;
+
+         BOOST_ASIO_CORO_YIELD
          boost::asio::experimental::make_parallel_group(
             [this](auto token) { return conn->reader(token);},
-            [this](auto token) { return conn->writer(token);},
-            [this](auto token) { return conn->async_check_idle(ts.ping_interval, token);},
-            [this](auto token) { return conn->async_ping(ts.ping_interval, token);}
+            [this](auto token) { return conn->writer(token);}
          ).async_wait(
             boost::asio::experimental::wait_for_one(),
             std::move(self));
@@ -370,83 +225,12 @@ struct start_op {
          switch (order[0]) {
            case 0: self.complete(ec0); break;
            case 1: self.complete(ec1); break;
-           case 2: self.complete(ec2); break;
-           case 3: self.complete(ec3); break;
            default: BOOST_ASSERT(false);
          }
       }
    }
 };
 
-inline
-auto check_resp3_handshake_failed(std::vector<resp3::node<std::string>> const& resp) -> bool
-{
-   return std::size(resp) == 1 && 
-         (resp.front().data_type == resp3::type::simple_error ||
-          resp.front().data_type == resp3::type::blob_error ||
-          resp.front().data_type == resp3::type::null);
-}
-
-template <class Conn, class Timeouts>
-struct run_op {
-   Conn* conn = nullptr;
-   Timeouts ts;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()(
-      Self& self,
-      boost::system::error_code ec = {},
-      std::size_t = 0)
-   {
-      reenter (coro)
-      {
-         yield conn->async_resolve_with_timeout(ts.resolve_timeout, std::move(self));
-         AEDIS_CHECK_OP0(conn->cancel(operation::run));
-
-         yield conn->derived().async_connect(conn->endpoints_, ts, conn->ping_timer_, std::move(self));
-         AEDIS_CHECK_OP0(conn->cancel(operation::run));
-
-         conn->prepare_hello(conn->ep_);
-         conn->ping_timer_.expires_after(ts.resp3_handshake_timeout);
-         conn->response_.clear();
-
-         yield
-         resp3::detail::async_exec(
-            conn->next_layer(),
-            conn->ping_timer_,
-            conn->req_,
-            adapter::adapt2(conn->response_),
-            conn->make_dynamic_buffer(),
-            std::move(self)
-         );
-
-         AEDIS_CHECK_OP0(conn->cancel(operation::run));
-
-         if (check_resp3_handshake_failed(conn->response_)) {
-            conn->cancel(operation::run);
-            self.complete(error::resp3_handshake_error);
-            return;
-         }
-
-         conn->ep_.password.clear();
-
-         if (!conn->expect_role(conn->ep_.role)) {
-            conn->cancel(operation::run);
-            self.complete(error::unexpected_server_role);
-            return;
-         }
-
-         conn->write_buffer_.clear();
-         conn->cmds_ = 0;
-
-         yield conn->async_start(ts, std::move(self));
-         AEDIS_CHECK_OP0();
-         self.complete({});
-      }
-   }
-};
-
 template <class Conn>
 struct writer_op {
    Conn* conn;
@@ -459,13 +243,13 @@ struct writer_op {
    {
       boost::ignore_unused(n);
 
-      reenter (coro) for (;;)
+      BOOST_ASIO_CORO_REENTER (coro) for (;;)
       {
          while (!conn->reqs_.empty() && conn->cmds_ == 0 && conn->write_buffer_.empty()) {
             conn->coalesce_requests();
-            yield
+            BOOST_ASIO_CORO_YIELD
             boost::asio::async_write(conn->next_layer(), boost::asio::buffer(conn->write_buffer_), std::move(self));
-            AEDIS_CHECK_OP0(conn->cancel(operation::run));
+            AEDIS_CHECK_OP0(conn->cancel(operation::run););
 
             conn->on_write();
 
@@ -478,7 +262,8 @@ struct writer_op {
             }
          }
 
-         yield conn->writer_timer_.async_wait(std::move(self));
+         BOOST_ASIO_CORO_YIELD
+         conn->writer_timer_.async_wait(std::move(self));
          if (!conn->is_open() || is_cancelled(self)) {
             // Notice this is not an error of the op, stoping was
             // requested from the outside, so we complete with
@@ -502,9 +287,9 @@ struct reader_op {
    {
       boost::ignore_unused(n);
 
-      reenter (coro) for (;;)
+      BOOST_ASIO_CORO_REENTER (coro) for (;;)
       {
-         yield
+         BOOST_ASIO_CORO_YIELD
          boost::asio::async_read_until(
             conn->next_layer(),
             conn->make_dynamic_buffer(),
@@ -515,9 +300,7 @@ struct reader_op {
             return self.complete({}); // EOFINAE: EOF is not an error.
          }
 
-         AEDIS_CHECK_OP0(conn->cancel(operation::run));
-
-         conn->last_data_ = std::chrono::steady_clock::now();
+         AEDIS_CHECK_OP0(conn->cancel(operation::run););
 
          // We handle unsolicited events in the following way
          //
@@ -540,25 +323,22 @@ struct reader_op {
          if (resp3::to_type(conn->read_buffer_.front()) == resp3::type::push
              || conn->reqs_.empty()
              || (!conn->reqs_.empty() && conn->reqs_.front()->get_number_of_commands() == 0)) {
-            yield async_send_receive(conn->push_channel_, std::move(self));
-            if (!conn->is_open() || ec || is_cancelled(self)) {
-               conn->cancel(operation::run);
-               self.complete(boost::asio::error::basic_errors::operation_aborted);
-               return;
-            }
+            BOOST_ASIO_CORO_YIELD
+            conn->guarded_op_.async_run(std::move(self));
          } else {
             BOOST_ASSERT(conn->cmds_ != 0);
             BOOST_ASSERT(!conn->reqs_.empty());
             BOOST_ASSERT(conn->reqs_.front()->get_number_of_commands() != 0);
             conn->reqs_.front()->proceed();
-            yield conn->read_timer_.async_wait(std::move(self));
-            if (!conn->is_open() || is_cancelled(self)) {
-               // Added this cancel here to make sure any outstanding
-               // ping is cancelled.
-               conn->cancel(operation::run);
-               self.complete(boost::asio::error::basic_errors::operation_aborted);
-               return;
-            }
+            BOOST_ASIO_CORO_YIELD
+            conn->read_timer_.async_wait(std::move(self));
+            ec = {};
+         }
+
+         if (!conn->is_open() || ec || is_cancelled(self)) {
+            conn->cancel(operation::run);
+            self.complete(boost::asio::error::basic_errors::operation_aborted);
+            return;
          }
       }
    }
@@ -566,5 +346,4 @@ struct reader_op {
 
 } // aedis::detail
 
-#include <boost/asio/unyield.hpp>
 #endif // AEDIS_CONNECTION_OPS_HPP

include/aedis/detail/guarded_operation.hpp

@@ -0,0 +1,111 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_DETAIL_GUARDED_OPERATION_HPP
+#define AEDIS_DETAIL_GUARDED_OPERATION_HPP
+
+#include <boost/asio/experimental/channel.hpp>
+
+namespace aedis::detail {
+
+template <class Executor>
+struct send_receive_op {
+   using channel_type = boost::asio::experimental::channel<Executor, void(boost::system::error_code, std::size_t)>;
+   channel_type* channel;
+   boost::asio::coroutine coro{};
+
+   template <class Self>
+   void operator()(Self& self, boost::system::error_code ec = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         BOOST_ASIO_CORO_YIELD
+         channel->async_send(boost::system::error_code{}, 0, std::move(self));
+         AEDIS_CHECK_OP0(;);
+
+         BOOST_ASIO_CORO_YIELD
+         channel->async_send(boost::system::error_code{}, 0, std::move(self));
+         AEDIS_CHECK_OP0(;);
+
+         self.complete({});
+      }
+   }
+};
+
+template <class Executor, class Op>
+struct wait_op {
+   using channel_type = boost::asio::experimental::channel<Executor, void(boost::system::error_code, std::size_t)>;
+   channel_type* channel;
+   Op op;
+   std::size_t res = 0;
+   boost::asio::coroutine coro{};
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , boost::system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         BOOST_ASIO_CORO_YIELD
+         channel->async_receive(std::move(self));
+         AEDIS_CHECK_OP1(;);
+
+         BOOST_ASIO_CORO_YIELD
+         std::move(op)(std::move(self));
+         AEDIS_CHECK_OP1(channel->cancel(););
+
+         res = n;
+
+         BOOST_ASIO_CORO_YIELD
+         channel->async_receive(std::move(self));
+         AEDIS_CHECK_OP1(;);
+
+         self.complete({}, res);
+         return;
+      }
+   }
+};
+
+template <class Executor>
+class guarded_operation {
+public:
+   using executor_type = Executor;
+   guarded_operation(executor_type ex) : channel_{ex} {}
+
+   template <class CompletionToken>
+   auto async_run(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(send_receive_op<executor_type>{&channel_}, token, channel_);
+   }
+
+   template <class Op, class CompletionToken>
+   auto async_wait(Op&& op, CompletionToken token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code, std::size_t)
+         >(wait_op<executor_type, Op>{&channel_, std::move(op)}, token, channel_);
+   }
+
+   void cancel() {channel_.cancel();}
+
+private:
+   using channel_type = boost::asio::experimental::channel<executor_type, void(boost::system::error_code, std::size_t)>;
+
+   template <class> friend struct send_receive_op;
+   template <class, class> friend struct wait_op;
+
+   channel_type channel_;
+};
+
+} // aedis::detail
+
+#endif // AEDIS_DETAIL_GUARDED_OPERATION_HPP

include/aedis/detail/net.hpp

@@ -1,205 +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)
- */
-
-#ifndef AEDIS_NET_HPP
-#define AEDIS_NET_HPP
-
-#include <array>
-
-#include <boost/system.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/connect.hpp>
-#include <boost/assert.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
-
-#include <boost/asio/yield.hpp>
-
-namespace aedis::detail {
-
-template <class Executor>
-using conn_timer_t = boost::asio::basic_waitable_timer<std::chrono::steady_clock, boost::asio::wait_traits<std::chrono::steady_clock>, Executor>;
-
-template <
-   class Stream,
-   class EndpointSequence
-   >
-struct connect_op {
-   Stream* socket;
-   conn_timer_t<typename Stream::executor_type>* timer;
-   EndpointSequence* endpoints;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , boost::system::error_code ec1 = {}
-                  , typename Stream::protocol_type::endpoint const& ep = {}
-                  , boost::system::error_code ec2 = {})
-   {
-      reenter (coro)
-      {
-         yield
-         boost::asio::experimental::make_parallel_group(
-            [this](auto token)
-            {
-               auto f = [](boost::system::error_code const&, auto const&) { return true; };
-               return boost::asio::async_connect(*socket, *endpoints, f, token);
-            },
-            [this](auto token) { return timer->async_wait(token);}
-         ).async_wait(
-            boost::asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(boost::asio::error::operation_aborted, {});
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: self.complete(ec1, ep); return;
-            case 1:
-            {
-               if (ec2) {
-                  self.complete(ec2, {});
-               } else {
-                  self.complete(error::connect_timeout, ep);
-               }
-               return;
-            }
-
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <class Resolver, class Timer>
-struct resolve_op {
-   Resolver* resv;
-   Timer* timer;
-   boost::string_view host;
-   boost::string_view port;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , boost::system::error_code ec1 = {}
-                  , boost::asio::ip::tcp::resolver::results_type res = {}
-                  , boost::system::error_code ec2 = {})
-   {
-      reenter (coro)
-      {
-         yield
-         boost::asio::experimental::make_parallel_group(
-            [this](auto token) { return resv->async_resolve(host.data(), port.data(), token);},
-            [this](auto token) { return timer->async_wait(token);}
-         ).async_wait(
-            boost::asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(boost::asio::error::operation_aborted, {});
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: self.complete(ec1, res); return;
-
-            case 1:
-            {
-               if (ec2) {
-                  self.complete(ec2, {});
-               } else {
-                  self.complete(error::resolve_timeout, {});
-               }
-               return;
-            }
-
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <class Channel>
-struct send_receive_op {
-   Channel* channel;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , std::size_t = 0)
-   {
-      reenter (coro)
-      {
-         yield
-         channel->async_send(boost::system::error_code{}, 0, std::move(self));
-         AEDIS_CHECK_OP1();
-
-         yield
-         channel->async_receive(std::move(self));
-         AEDIS_CHECK_OP1();
-
-         self.complete({}, 0);
-      }
-   }
-};
-
-template <
-   class Stream,
-   class EndpointSequence,
-   class CompletionToken
-   >
-auto async_connect(
-      Stream& socket,
-      conn_timer_t<typename Stream::executor_type>& timer,
-      EndpointSequence ep,
-      CompletionToken&& token)
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, typename Stream::protocol_type::endpoint const&)
-      >(connect_op<Stream, EndpointSequence>
-            {&socket, &timer, &ep}, token, socket, timer);
-}
-
-template <
-   class Resolver,
-   class Timer,
-   class CompletionToken =
-      boost::asio::default_completion_token_t<typename Resolver::executor_type>
-   >
-auto async_resolve(
-      Resolver& resv,
-      Timer& timer,
-      boost::string_view host,
-      boost::string_view port,
-      CompletionToken&& token = CompletionToken{})
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, boost::asio::ip::tcp::resolver::results_type)
-      >(resolve_op<Resolver, Timer>{&resv, &timer, host, port}, token, resv, timer);
-}
-
-template <
-   class Channel,
-   class CompletionToken =
-      boost::asio::default_completion_token_t<typename Channel::executor_type>
-   >
-auto async_send_receive(Channel& channel, CompletionToken&& token = CompletionToken{})
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, std::size_t)
-      >(send_receive_op<Channel>{&channel}, token, channel);
-}
-} // aedis::detail
-
-#include <boost/asio/unyield.hpp>
-#endif // AEDIS_NET_HPP

include/aedis/endpoint.hpp

@@ -1,38 +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)
- */
-
-#ifndef AEDIS_ENDPOINT_HPP
-#define AEDIS_ENDPOINT_HPP
-
-#include <string>
-
-namespace aedis {
-
-/** \brief A Redis endpoint.
- *  \ingroup high-level-api
- */
-struct endpoint {
-   /// Redis server address.
-   std::string host;
-
-   /// Redis server port.
-   std::string port;
-
-   /// Expected role if any.
-   std::string role{};
-
-   /// Username if authentication is required.
-   std::string username{};
-
-   /// Password if authentication is required.
-   std::string password{};
-};
-
-auto requires_auth(endpoint const& ep) noexcept -> bool;
-
-} // aedis
-
-#endif // AEDIS_ENDPOINT_HPP

include/aedis/error.hpp

@@ -16,20 +16,8 @@ namespace aedis {
  */
 enum class error
 {
-   /// Resolve timeout.
-   resolve_timeout = 1,
-
-   /// Connect timeout.
-   connect_timeout,
-
-   /// Idle timeout.
-   idle_timeout,
-
-   /// Exec timeout.
-   exec_timeout,
-
    /// Invalid RESP3 type.
-   invalid_data_type,
+   invalid_data_type = 1,
 
    /// Can't parse the string as a number.
    not_a_number,
@@ -73,17 +61,8 @@ enum class error
    /// Got RESP3 null.
    resp3_null,
 
-   /// Unexpected server role.
-   unexpected_server_role,
-
-   /// SSL handshake timeout.
-   ssl_handshake_timeout,
-
    /// There is no stablished connection.
    not_connected,
-
-   /// RESP3 handshake error (HELLO command).
-   resp3_handshake_error,
 };
 
 /** \internal

include/aedis/impl/endpoint.ipp

@@ -1,18 +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 <aedis/endpoint.hpp>
-
-#include <string>
-
-namespace aedis {
-
-auto requires_auth(endpoint const& ep) noexcept -> bool
-{
-   return !std::empty(ep.username) && !std::empty(ep.password);
-}
-
-} // aedis

include/aedis/impl/error.ipp

@@ -5,6 +5,7 @@
  */
 
 #include <aedis/error.hpp>
+#include <boost/assert.hpp>
 
 namespace aedis {
 namespace detail {
@@ -21,10 +22,6 @@ struct error_category_impl : boost::system::error_category {
    auto message(int ev) const -> std::string override
    {
       switch(static_cast<error>(ev)) {
-	 case error::resolve_timeout: return "Resolve operation timeout.";
-	 case error::connect_timeout: return "Connect operation timeout.";
-	 case error::idle_timeout: return "Idle timeout.";
-	 case error::exec_timeout: return "Exec timeout.";
 	 case error::invalid_data_type: return "Invalid resp3 type.";
 	 case error::not_a_number: return "Can't convert string to number.";
 	 case error::exceeeds_max_nested_depth: return "Exceeds the maximum number of nested responses.";
@@ -40,10 +37,7 @@ struct error_category_impl : boost::system::error_category {
 	 case error::incompatible_size: return "Aggregate container has incompatible size.";
 	 case error::not_a_double: return "Not a double.";
 	 case error::resp3_null: return "Got RESP3 null.";
-	 case error::unexpected_server_role: return "Unexpected server role.";
-	 case error::ssl_handshake_timeout: return "SSL handshake timeout.";
 	 case error::not_connected: return "Not connected.";
-	 case error::resp3_handshake_error: return "RESP3 handshake error (HELLO command).";
 	 default: BOOST_ASSERT(false); return "Aedis error.";
       }
    }

include/aedis/resp3/detail/exec.hpp

@@ -1,173 +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)
- */
-
-#ifndef AEDIS_RESP3_EXEC_HPP
-#define AEDIS_RESP3_EXEC_HPP
-
-#include <boost/assert.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/read.hpp>
-#include <boost/asio/write.hpp>
-#include <boost/asio/coroutine.hpp>
-#include <boost/asio/compose.hpp>
-#include <boost/asio/steady_timer.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
-
-#include <aedis/error.hpp>
-#include <aedis/resp3/read.hpp>
-#include <aedis/resp3/request.hpp>
-
-#include <boost/asio/yield.hpp>
-
-namespace aedis::resp3::detail {
-
-template <
-   class AsyncStream,
-   class Adapter,
-   class DynamicBuffer
-   >
-struct exec_op {
-   AsyncStream* socket = nullptr;
-   request const* req = nullptr;
-   Adapter adapter;
-   DynamicBuffer dbuf{};
-   std::size_t n_cmds = 0;
-   std::size_t size = 0;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      reenter (coro) for (;;)
-      {
-         if (req) {
-            yield
-            boost::asio::async_write(
-               *socket,
-               boost::asio::buffer(req->payload()),
-               std::move(self));
-            AEDIS_CHECK_OP1();
-
-            if (n_cmds == 0) {
-               return self.complete({}, n);
-            }
-
-            req = nullptr;
-         }
-
-         yield resp3::async_read(*socket, dbuf, adapter, std::move(self));
-         AEDIS_CHECK_OP1();
-
-         size += n;
-         if (--n_cmds == 0) {
-            return self.complete(ec, size);
-         }
-      }
-   }
-};
-
-template <
-   class AsyncStream,
-   class Adapter,
-   class DynamicBuffer,
-   class CompletionToken = boost::asio::default_completion_token_t<typename AsyncStream::executor_type>
-   >
-auto async_exec(
-   AsyncStream& socket,
-   request const& req,
-   Adapter adapter,
-   DynamicBuffer dbuf,
-   CompletionToken token = CompletionToken{})
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, std::size_t)
-      >(detail::exec_op<AsyncStream, Adapter, DynamicBuffer>
-         {&socket, &req, adapter, dbuf, req.size()}, token, socket);
-}
-
-template <
-   class AsyncStream,
-   class Timer,
-   class Adapter,
-   class DynamicBuffer
-   >
-struct exec_with_timeout_op {
-   AsyncStream* socket = nullptr;
-   Timer* timer = nullptr;
-   request const* req = nullptr;
-   Adapter adapter;
-   DynamicBuffer dbuf{};
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , boost::system::error_code ec1 = {}
-                  , std::size_t n = 0
-                  , boost::system::error_code ec2 = {})
-   {
-      reenter (coro)
-      {
-         yield
-         boost::asio::experimental::make_parallel_group(
-            [this](auto token) { return detail::async_exec(*socket, *req, adapter, dbuf, token);},
-            [this](auto token) { return timer->async_wait(token);}
-         ).async_wait(
-            boost::asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(boost::asio::error::operation_aborted, 0);
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: self.complete(ec1, n); break;
-            case 1:
-            {
-               if (ec2) {
-                  self.complete(ec2, 0);
-               } else {
-                  self.complete(aedis::error::exec_timeout, 0);
-               }
-
-            } break;
-
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <
-   class AsyncStream,
-   class Timer,
-   class Adapter,
-   class DynamicBuffer,
-   class CompletionToken = boost::asio::default_completion_token_t<typename AsyncStream::executor_type>
-   >
-auto async_exec(
-   AsyncStream& socket,
-   Timer& timer,
-   request const& req,
-   Adapter adapter,
-   DynamicBuffer dbuf,
-   CompletionToken token = CompletionToken{})
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, std::size_t)
-      >(detail::exec_with_timeout_op<AsyncStream, Timer, Adapter, DynamicBuffer>
-         {&socket, &timer, &req, adapter, dbuf}, token, socket, timer);
-}
-
-} // aedis::resp3::detail
-
-#include <boost/asio/unyield.hpp>
-#endif // AEDIS_RESP3_EXEC_HPP

include/aedis/resp3/detail/impl/parser.ipp

@@ -4,22 +4,153 @@
  * accompanying file LICENSE.txt)
  */
 
-#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/home/x3.hpp>
-
 #include <aedis/resp3/detail/parser.hpp>
-#include <aedis/resp3/type.hpp>
+#include <aedis/error.hpp>
+
+#include <boost/assert.hpp>
+
+#include <charconv>
 
 namespace aedis::resp3::detail {
 
-auto parse_uint(char const* data, std::size_t size, boost::system::error_code& ec) -> std::size_t
+void to_int(int_type& i, std::string_view sv, boost::system::error_code& ec)
 {
-   static constexpr boost::spirit::x3::uint_parser<std::size_t, 10> p{};
-   std::size_t ret = 0;
-   if (!parse(data, data + size, p, ret))
+   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
+   if (res.ec != std::errc())
       ec = error::not_a_number;
-
-   return ret;
 }
 
+parser::parser()
+{
+   sizes_[0] = 2; // The sentinel must be more than 1.
+}
+
+auto
+parser::consume(
+   char const* data,
+   std::size_t n,
+   boost::system::error_code& ec) -> std::pair<node_type, std::size_t>
+{
+   node_type ret;
+   if (bulk_expected()) {
+      n = bulk_length_ + 2;
+      ret = {bulk_, 1, depth_, {data, bulk_length_}};
+      bulk_ = type::invalid;
+      --sizes_[depth_];
+
+   } else if (sizes_[depth_] != 0) {
+      auto const t = to_type(*data);
+      switch (t) {
+         case type::streamed_string_part:
+         {
+            to_int(bulk_length_ , std::string_view{data + 1, n - 3}, ec);
+            if (ec)
+               return std::make_pair(node_type{}, 0);
+
+            if (bulk_length_ == 0) {
+               ret = {type::streamed_string_part, 1, depth_, {}};
+               sizes_[depth_] = 0; // We are done.
+               bulk_ = type::invalid;
+            } else {
+               bulk_ = type::streamed_string_part;
+            }
+         } break;
+         case type::blob_error:
+         case type::verbatim_string:
+         case type::blob_string:
+         {
+            if (data[1] == '?') {
+               // NOTE: This can only be triggered with blob_string.
+               // Trick: A streamed string is read as an aggregate
+               // of infinite lenght. When the streaming is done
+               // the server is supposed to send a part with length
+               // 0.
+               sizes_[++depth_] = (std::numeric_limits<std::size_t>::max)();
+               ret = {type::streamed_string, 0, depth_, {}};
+            } else {
+               to_int(bulk_length_ , std::string_view{data + 1, n - 3} , ec);
+               if (ec)
+                  return std::make_pair(node_type{}, 0);
+
+               bulk_ = t;
+            }
+         } break;
+         case type::boolean:
+         {
+            if (n == 3) {
+                ec = error::empty_field;
+                return std::make_pair(node_type{}, 0);
+            }
+
+            if (data[1] != 'f' && data[1] != 't') {
+                ec = error::unexpected_bool_value;
+                return std::make_pair(node_type{}, 0);
+            }
+
+            ret = {t, 1, depth_, {data + 1, n - 3}};
+            --sizes_[depth_];
+         } break;
+         case type::doublean:
+         case type::big_number:
+         case type::number:
+         {
+            if (n == 3) {
+                ec = error::empty_field;
+                return std::make_pair(node_type{}, 0);
+            }
+
+            ret = {t, 1, depth_, {data + 1, n - 3}};
+            --sizes_[depth_];
+         } break;
+         case type::simple_error:
+         case type::simple_string:
+         {
+            ret = {t, 1, depth_, {&data[1], n - 3}};
+            --sizes_[depth_];
+         } break;
+         case type::null:
+         {
+            ret = {type::null, 1, depth_, {}};
+            --sizes_[depth_];
+         } break;
+         case type::push:
+         case type::set:
+         case type::array:
+         case type::attribute:
+         case type::map:
+         {
+            int_type l = -1;
+            to_int(l, std::string_view{data + 1, n - 3}, ec);
+            if (ec)
+               return std::make_pair(node_type{}, 0);
+
+            ret = {t, l, depth_, {}};
+            if (l == 0) {
+               --sizes_[depth_];
+            } else {
+               if (depth_ == max_embedded_depth) {
+                  ec = error::exceeeds_max_nested_depth;
+                  return std::make_pair(node_type{}, 0);
+               }
+
+               ++depth_;
+
+               sizes_[depth_] = l * element_multiplicity(t);
+            }
+         } break;
+         default:
+         {
+            ec = error::invalid_data_type;
+            return std::make_pair(node_type{}, 0);
+         }
+      }
+   }
+   
+   while (sizes_[depth_] == 0) {
+      --depth_;
+      --sizes_[depth_];
+   }
+   
+   return std::make_pair(ret, n);
+}
 } // aedis::resp3::detail

include/aedis/resp3/detail/parser.hpp

@@ -7,28 +7,22 @@
 #ifndef AEDIS_RESP3_PARSER_HPP
 #define AEDIS_RESP3_PARSER_HPP
 
+#include <aedis/resp3/node.hpp>
+
 #include <array>
 #include <limits>
-#include <system_error>
-
-#include <boost/assert.hpp>
-#include <boost/utility/string_view.hpp>
-
-#include <aedis/error.hpp>
-#include <aedis/resp3/node.hpp>
+#include <string_view>
+#include <cstdint>
 
 namespace aedis::resp3::detail {
 
-auto parse_uint(char const* data, std::size_t size, boost::system::error_code& ec) -> std::size_t;
+using int_type = std::uint64_t;
 
-template <class ResponseAdapter>
 class parser {
 private:
-   using node_type = node<boost::string_view>;
+   using node_type = node<std::string_view>;
    static constexpr std::size_t max_embedded_depth = 5;
 
-   ResponseAdapter adapter_;
-
    // The current depth. Simple data types will have depth 0, whereas
    // the elements of aggregates will have depth 1. Embedded types
    // will have increasing depth.
@@ -40,182 +34,34 @@ private:
    std::array<std::size_t, max_embedded_depth + 1> sizes_ = {{1}};
 
    // Contains the length expected in the next bulk read.
-   std::size_t bulk_length_ = (std::numeric_limits<std::size_t>::max)();
+   int_type bulk_length_ = (std::numeric_limits<unsigned long>::max)();
 
    // The type of the next bulk. Contains type::invalid if no bulk is
    // expected.
    type bulk_ = type::invalid;
 
 public:
-   explicit parser(ResponseAdapter adapter)
-   : adapter_{adapter}
-   {
-      sizes_[0] = 2; // The sentinel must be more than 1.
-   }
+   parser();
 
    // Returns the number of bytes that have been consumed.
    auto
-   consume(char const* data, std::size_t n, boost::system::error_code& ec) -> std::size_t
-   {
-      if (bulk_ != type::invalid) {
-         n = bulk_length_ + 2;
-         switch (bulk_) {
-            case type::streamed_string_part:
-            {
-               BOOST_ASSERT(bulk_length_ != 0);
-               adapter_({bulk_, 1, depth_, {data, bulk_length_}}, ec);
-               if (ec)
-                  return 0;
-            } break;
-            default:
-	    {
-	       adapter_({bulk_, 1, depth_, {data, bulk_length_}}, ec);
-	       if (ec)
-		  return 0;
-	    }
-         }
-
-         bulk_ = type::invalid;
-         --sizes_[depth_];
-
-      } else if (sizes_[depth_] != 0) {
-         auto const t = to_type(*data);
-         switch (t) {
-            case type::streamed_string_part:
-            {
-               bulk_length_ = parse_uint(data + 1, n - 2, ec);
-	       if (ec)
-		  return 0;
-
-               if (bulk_length_ == 0) {
-                  adapter_({type::streamed_string_part, 1, depth_, {}}, ec);
-                  sizes_[depth_] = 0; // We are done.
-               } else {
-                  bulk_ = type::streamed_string_part;
-               }
-            } break;
-            case type::blob_error:
-            case type::verbatim_string:
-            case type::blob_string:
-            {
-               if (data[1] == '?') {
-                  // NOTE: This can only be triggered with blob_string.
-		  // Trick: A streamed string is read as an aggregate
-		  // of infinite lenght. When the streaming is done
-		  // the server is supposed to send a part with length
-		  // 0.
-                  sizes_[++depth_] = (std::numeric_limits<std::size_t>::max)();
-               } else {
-                  bulk_length_ = parse_uint(data + 1, n - 2, ec);
-                  if (ec)
-                     return 0;
-
-                  bulk_ = t;
-               }
-            } break;
-            case type::boolean:
-            {
-               if (n == 3) {
-                   ec = error::empty_field;
-                   return 0;
-               }
-
-               if (data[1] != 'f' && data[1] != 't') {
-                   ec = error::unexpected_bool_value;
-                   return 0;
-               }
-
-               adapter_({t, 1, depth_, {data + 1, n - 3}}, ec);
-	       if (ec)
-		  return 0;
-
-               --sizes_[depth_];
-            } break;
-            case type::doublean:
-            case type::big_number:
-            case type::number:
-            {
-               if (n == 3) {
-                   ec = error::empty_field;
-                   return 0;
-               }
-
-               adapter_({t, 1, depth_, {data + 1, n - 3}}, ec);
-	       if (ec)
-		  return 0;
-
-               --sizes_[depth_];
-            } break;
-            case type::simple_error:
-            case type::simple_string:
-            {
-               adapter_({t, 1, depth_, {&data[1], n - 3}}, ec);
-	       if (ec)
-		  return 0;
-
-               --sizes_[depth_];
-            } break;
-            case type::null:
-            {
-               adapter_({type::null, 1, depth_, {}}, ec);
-	       if (ec)
-		  return 0;
-
-               --sizes_[depth_];
-            } break;
-            case type::push:
-            case type::set:
-            case type::array:
-            case type::attribute:
-            case type::map:
-            {
-	       auto const l = parse_uint(data + 1, n - 2, ec);
-               if (ec)
-                  return 0;
-
-               adapter_({t, l, depth_, {}}, ec);
-	       if (ec)
-		  return 0;
-
-               if (l == 0) {
-                  --sizes_[depth_];
-               } else {
-		  if (depth_ == max_embedded_depth) {
-		     ec = error::exceeeds_max_nested_depth;
-		     return 0;
-		  }
-
-                  ++depth_;
-
-                  sizes_[depth_] = l * element_multiplicity(t);
-               }
-            } break;
-            default:
-            {
-	       ec = error::invalid_data_type;
-	       return 0;
-            }
-         }
-      }
-      
-      while (sizes_[depth_] == 0) {
-         --depth_;
-         --sizes_[depth_];
-      }
-      
-      return n;
-   }
+   consume(
+      char const* data,
+      std::size_t n,
+      boost::system::error_code& ec) -> std::pair<node_type, std::size_t>;
 
    // Returns true when the parser is done with the current message.
    [[nodiscard]] auto done() const noexcept
       { return depth_ == 0 && bulk_ == type::invalid; }
 
-   // The bulk type expected in the next read. If none is expected returns
-   // type::invalid.
-   [[nodiscard]] auto bulk() const noexcept { return bulk_; }
+   // The bulk type expected in the next read. If none is expected
+   // returns type::invalid.
+   [[nodiscard]] auto bulk_expected() const noexcept -> bool
+      { return bulk_ != type::invalid; }
 
    // The length expected in the the next bulk.
-   [[nodiscard]] auto bulk_length() const noexcept { return bulk_length_; }
+   [[nodiscard]] auto bulk_length() const noexcept
+      { return bulk_length_; }
 };
 
 } // detail::resp3::aedis

include/aedis/resp3/detail/read_ops.hpp

@@ -7,15 +7,15 @@
 #ifndef AEDIS_RESP3_READ_OPS_HPP
 #define AEDIS_RESP3_READ_OPS_HPP
 
+#include <aedis/resp3/detail/parser.hpp>
+
 #include <boost/assert.hpp>
 #include <boost/asio/read.hpp>
 #include <boost/asio/read_until.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/core/ignore_unused.hpp>
-#include <boost/utility/string_view.hpp>
-#include <aedis/resp3/detail/parser.hpp>
 
-#include <boost/asio/yield.hpp>
+#include <string_view>
 
 namespace aedis::detail
 {
@@ -28,14 +28,14 @@ auto is_cancelled(T const& self)
 
 #define AEDIS_CHECK_OP0(X)\
    if (ec || aedis::detail::is_cancelled(self)) {\
-      X;\
+      X\
       self.complete(!!ec ? ec : boost::asio::error::operation_aborted);\
       return;\
    }
 
 #define AEDIS_CHECK_OP1(X)\
    if (ec || aedis::detail::is_cancelled(self)) {\
-      X;\
+      X\
       self.complete(!!ec ? ec : boost::asio::error::operation_aborted, {});\
       return;\
    }
@@ -43,7 +43,7 @@ auto is_cancelled(T const& self)
 namespace aedis::resp3::detail {
 
 struct ignore_response {
-   void operator()(node<boost::string_view> nd, boost::system::error_code& ec)
+   void operator()(node<std::string_view> nd, boost::system::error_code& ec)
    {
       switch (nd.data_type) {
          case resp3::type::simple_error: ec = error::resp3_simple_error; return;
@@ -61,7 +61,8 @@ class parse_op {
 private:
    AsyncReadStream& stream_;
    DynamicBuffer buf_;
-   parser<ResponseAdapter> parser_;
+   parser parser_;
+   ResponseAdapter adapter_;
    std::size_t consumed_ = 0;
    std::size_t buffer_size_ = 0;
    boost::asio::coroutine coro_{};
@@ -70,7 +71,7 @@ public:
    parse_op(AsyncReadStream& stream, DynamicBuffer buf, ResponseAdapter adapter)
    : stream_ {stream}
    , buf_ {std::move(buf)}
-   , parser_ {std::move(adapter)}
+   , adapter_ {std::move(adapter)}
    { }
 
    template <class Self>
@@ -78,11 +79,11 @@ public:
                   , boost::system::error_code ec = {}
                   , std::size_t n = 0)
    {
-      reenter (coro_) for (;;) {
-         if (parser_.bulk() == type::invalid) {
-            yield
+      BOOST_ASIO_CORO_REENTER (coro_) for (;;) {
+         if (!parser_.bulk_expected()) {
+            BOOST_ASIO_CORO_YIELD
             boost::asio::async_read_until(stream_, buf_, "\r\n", std::move(self));
-            AEDIS_CHECK_OP1();
+            AEDIS_CHECK_OP1(;);
          } else {
 	    // On a bulk read we can't read until delimiter since the
 	    // payload may contain the delimiter itself so we have to
@@ -95,27 +96,31 @@ public:
                buffer_size_ = buf_.size();
                buf_.grow(parser_.bulk_length() + 2 - buffer_size_);
 
-               yield
+               BOOST_ASIO_CORO_YIELD
                boost::asio::async_read(
                   stream_,
                   buf_.data(buffer_size_, parser_.bulk_length() + 2 - buffer_size_),
                   boost::asio::transfer_all(),
                   std::move(self));
-               AEDIS_CHECK_OP1();
+               AEDIS_CHECK_OP1(;);
             }
 
             n = parser_.bulk_length() + 2;
             BOOST_ASSERT(buf_.size() >= n);
          }
 
-         n = parser_.consume(static_cast<char const*>(buf_.data(0, n).data()), n, ec);
-         if (ec) {
-            self.complete(ec, 0);
-            return;
+         auto const res = parser_.consume(static_cast<char const*>(buf_.data(0, n).data()), n, ec);
+         if (ec)
+            return self.complete(ec, 0);
+
+         if (!parser_.bulk_expected()) {
+            adapter_(res.first, ec);
+            if (ec)
+               return self.complete(ec, 0);
          }
 
-         buf_.consume(n);
-         consumed_ += n;
+         buf_.consume(res.second);
+         consumed_ += res.second;
          if (parser_.done()) {
             self.complete({}, consumed_);
             return;
@@ -126,5 +131,4 @@ public:
 
 } // aedis::resp3::detail
 
-#include <boost/asio/unyield.hpp>
 #endif // AEDIS_RESP3_READ_OPS_HPP

include/aedis/resp3/impl/request.ipp

@@ -6,9 +6,11 @@
 
 #include <aedis/resp3/request.hpp>
 
+#include <string_view>
+
 namespace aedis::resp3::detail {
 
-auto has_push_response(boost::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/impl/type.ipp

@@ -4,8 +4,8 @@
  * accompanying file LICENSE.txt)
  */
 
-#include <boost/assert.hpp>
 #include <aedis/resp3/type.hpp>
+#include <boost/assert.hpp>
 
 namespace aedis::resp3 {
 
@@ -27,6 +27,7 @@ auto to_string(type t) -> char const*
       case type::blob_error: return "blob_error";
       case type::verbatim_string: return "verbatim_string";
       case type::blob_string: return "blob_string";
+      case type::streamed_string: return "streamed_string";
       case type::streamed_string_part: return "streamed_string_part";
       default: return "invalid";
    }

include/aedis/resp3/node.hpp

@@ -9,19 +9,38 @@
 
 #include <aedis/resp3/type.hpp>
 
-#include <string>
-#include <vector>
-
 namespace aedis::resp3 {
 
 /** \brief A node in the response tree.
  *  \ingroup high-level-api
  *
- *  Redis responses are the pre-order view of the response tree (see
- *  https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR).
+ *  RESP3 can contain recursive data structures: A map of sets of
+ *  vector of etc. As it is parsed each element is passed to user
+ *  callbacks (push parser), the `aedis::adapt` function. The signature of this
+ *  callback is `f(resp3::node<std::string_view)`. This class is called a node
+ *  because it can be seen as the element of the response tree. It
+ *  is a template so that users can use it with owing strings e.g.
+ *  `std::string` or `boost::static_string` etc. if they decide to use a node as
+ *  response type, for example, to read a non-aggregate data-type use
  *
- *  \remark Any Redis response can be received in an array of nodes,
- *  for example \c std::vector<node<std::string>>.
+ *  ```cpp
+ *  resp3::node<std::string> resp;
+ *  co_await conn->async_exec(req, adapt(resp));
+ *  ```
+ *
+ *  for an aggregate use instead
+ *
+ *  ```cpp
+ *  std::vector<resp3::node<std::string>> resp; co_await
+ *  conn->async_exec(req, adapt(resp));
+ *  ```
+ *
+ *  The vector will contain the
+ *  [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
+ *  view of the response tree.  Any Redis response can be received in
+ *  an array of nodes as shown above.
+ *
+ *  \tparam String A `std::string`-like type.
  */
 template <class String>
 struct node {
@@ -38,27 +57,6 @@ struct node {
    String value{};
 };
 
-/** @brief Converts the node to a string.
- *  @relates node
- *
- *  @param in The node object.
- */
-template <class String>
-auto to_string(node<String> const& in)
-{
-   std::string out;
-   out += std::to_string(in.depth);
-   out += '\t';
-   out += to_string(in.data_type);
-   out += '\t';
-   out += std::to_string(in.aggregate_size);
-   out += '\t';
-   if (!is_aggregate(in.data_type))
-      out.append(in.value.data(), in.value.size());
-
-   return out;
-}
-
 /** @brief Compares a node for equality.
  *  @relates node
  *
@@ -74,21 +72,6 @@ auto operator==(node<String> const& a, node<String> const& b)
        && a.value == b.value;
 };
 
-/** @brief Writes the node string to the stream.
- *  @relates node
- *
- *  @param os Output stream.
- *  @param node Node object.
- *
- *  \remark Binary data is not converted to text.
- */
-template <class String>
-auto operator<<(std::ostream& os, node<String> const& node) -> std::ostream&
-{
-   os << to_string(node);
-   return os;
-}
-
 } // aedis::resp3
 
 #endif // AEDIS_RESP3_NODE_HPP

include/aedis/resp3/read.hpp

@@ -59,11 +59,11 @@ read(
    ResponseAdapter adapter,
    boost::system::error_code& ec) -> std::size_t
 {
-   detail::parser<ResponseAdapter> p {adapter};
+   detail::parser p;
    std::size_t n = 0;
    std::size_t consumed = 0;
    do {
-      if (p.bulk() == type::invalid) {
+      if (!p.bulk_expected()) {
 	 n = boost::asio::read_until(stream, buf, "\r\n", ec);
 	 if (ec)
 	    return 0;
@@ -81,12 +81,18 @@ read(
       }
 
       auto const* data = static_cast<char const*>(buf.data(0, n).data());
-      n = p.consume(data, n, ec);
+      auto const res = p.consume(data, n, ec);
       if (ec)
          return 0;
 
-      buf.consume(n);
-      consumed += n;
+      if (!p.bulk_expected()) {
+         adapter(res.first, ec);
+         if (ec)
+            return 0;
+      }
+
+      buf.consume(res.second);
+      consumed += res.second;
    } while (!p.done());
 
    return consumed;

include/aedis/resp3/request.hpp

@@ -7,15 +7,12 @@
 #ifndef AEDIS_RESP3_REQUEST_HPP
 #define AEDIS_RESP3_REQUEST_HPP
 
+#include <aedis/resp3/type.hpp>
+
 #include <string>
 #include <tuple>
 #include <memory_resource>
 
-#include <boost/hana.hpp>
-#include <boost/utility/string_view.hpp>
-
-#include <aedis/resp3/type.hpp>
-
 // NOTE: Consider detecting tuples in the type in the parameter pack
 // to calculate the header size correctly.
 //
@@ -46,7 +43,7 @@ constexpr char const* separator = "\r\n";
  *  See more in @ref serialization.
  */
 template <class Request>
-void to_bulk(Request& to, boost::string_view data)
+void to_bulk(Request& to, std::string_view data)
 {
    auto const str = std::to_string(data.size());
 
@@ -61,12 +58,12 @@ template <class Request, class T, typename = typename std::enable_if<std::is_int
 void to_bulk(Request& to, T n)
 {
    auto const s = std::to_string(n);
-   to_bulk(to, boost::string_view{s});
+   to_bulk(to, std::string_view{s});
 }
 
 namespace detail {
 
-auto has_push_response(boost::string_view cmd) -> bool;
+auto has_response(std::string_view cmd) -> bool;
 
 template <class T>
 struct add_bulk_impl {
@@ -78,6 +75,21 @@ struct add_bulk_impl {
    }
 };
 
+template <class ...Ts>
+struct add_bulk_impl<std::tuple<Ts...>> {
+   template <class Request>
+   static void add(Request& to, std::tuple<Ts...> const& t)
+   {
+      auto f = [&](auto const&... vs)
+      {
+         using namespace aedis::resp3;
+         (to_bulk(to, vs), ...);
+      };
+
+      std::apply(f, t);
+   }
+};
+
 template <class U, class V>
 struct add_bulk_impl<std::pair<U, V>> {
    template <class Request>
@@ -89,23 +101,6 @@ struct add_bulk_impl<std::pair<U, V>> {
    }
 };
 
-template <class ...Ts>
-struct add_bulk_impl<boost::hana::tuple<Ts...>> {
-   template <class Request>
-   static void add(Request& to, boost::hana::tuple<Ts...> const& from)
-   {
-      using boost::hana::for_each;
-
-      // Fold expressions is C++17 so we use hana.
-      //(detail::add_bulk(*request_, args), ...);
-
-      for_each(from, [&](auto const& e) {
-         using namespace aedis::resp3;
-         to_bulk(to, e);
-      });
-   }
-};
-
 template <class Request>
 void add_header(Request& to, type t, std::size_t size)
 {
@@ -136,7 +131,7 @@ struct bulk_counter<std::pair<T, U>> {
 };
 
 template <class Request>
-void add_blob(Request& to, boost::string_view blob)
+void add_blob(Request& to, std::string_view blob)
 {
    to.append(std::cbegin(blob), std::cend(blob));
    to += separator;
@@ -169,37 +164,45 @@ void add_separator(Request& to)
  *
  *  \li Non-string types will be converted to string by using \c
  *  to_bulk, which must be made available over ADL.
- *  \li Uses std::string as internal storage.
+ *  \li Uses a std::pmr::string for internal storage.
  */
 class request {
 public:
    /// Request configuration options.
    struct config {
-      /** \brief If set to true, requests started with
-       * `aedis::connection::async_exec` will fail if the connection is
-       * lost while the request is pending. The default
-       * behaviour is not to close requests.
+      /** \brief If `true` 
+       * `aedis::connection::async_exec` will complete with error if the
+       * connection is lost. Affects only requests that haven't been
+       * sent yet.
        */
-      bool cancel_on_connection_lost = false;
+      bool cancel_on_connection_lost = true;
 
-      /** \brief If true this request will be coalesced with other requests,
-       *  see https://redis.io/topics/pipelining. If false, this
-       *  request will be sent individually.
+      /** \brief If `true` the request will be coalesced with other
+       * requests, see https://redis.io/topics/pipelining. Otherwise
+       * the request is sent individually.
        */
       bool coalesce = true;
 
-      /** \brief If set to true, requests started with
-       * `aedis::connection::async_exec` will fail if the call happens
-       *  before the connection with Redis was stablished.
+      /** \brief If `true` the request will complete with
+       * aedis::error::not_connected if `async_exec` is called before
+       * the connection with Redis was established.
        */
       bool cancel_if_not_connected = false;
 
-      /** \brief If true, the implementation will resend this
-       * request if it remained unresponded when
-       * `aedis::connection::async_run` completed. Has effect only if
-       * cancel_on_connection_lost is true.
+      /** \brief If `false` `aedis::connection::async_exec` will not
+       * automatically cancel this request if the connection is lost.
+       * Affects only requests that have been written to the socket
+       * but remained unresponded when `aedis::connection::async_run`
+       * completed.
        */
-      bool retry = true;
+      bool cancel_if_unresponded = true;
+
+      /** \brief If this request has a `HELLO` command and this flag is
+       * `true`, the `aedis::connection` will move it to the front of
+       * the queue of awaiting requests. This makes it possible to
+       * send `HELLO` and authenticate before other commands are sent.
+       */
+      bool hello_with_priority = true;
    };
 
    /** \brief Constructor
@@ -208,17 +211,19 @@ public:
     *  \param resource Memory resource.
     */
     explicit
-    request(config cfg = config{false, true, false, true},
+    request(config cfg = config{true, true, false, true, true},
             std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-    : payload_(resource), cfg_{cfg}
-    {}
-
+    : cfg_{cfg}, payload_(resource) {}
 
     //// Returns the number of commands contained in this request.
-   [[nodiscard]] auto size() const noexcept -> std::size_t { return commands_;};
+   [[nodiscard]] auto size() const noexcept -> std::size_t
+      { return commands_;};
 
-   // Returns the request payload.
-   [[nodiscard]] auto payload() const noexcept -> auto const& { return payload_;}
+   [[nodiscard]] auto payload() const noexcept -> auto const&
+      { return payload_;}
+
+   [[nodiscard]] auto has_hello_priority() const noexcept -> auto const&
+      { return has_hello_priority_;}
 
    /// Clears the request preserving allocated memory.
    void clear()
@@ -227,6 +232,16 @@ public:
       commands_ = 0;
    }
 
+   /// Calls std::pmr::string::reserve on the internal storage.
+   void reserve(std::size_t new_cap = 0)
+      { payload_.reserve(new_cap); }
+
+   /// Returns a const reference to the config object.
+   [[nodiscard]] auto get_config() const noexcept -> auto const& {return cfg_; }
+
+   /// Returns a reference to the config object.
+   [[nodiscard]] auto get_config() noexcept -> auto& {return cfg_; }
+
    /** @brief Appends a new command to the end of the request.
     *
     *  For example
@@ -243,19 +258,16 @@ public:
     *  \param args Command arguments.
     */
    template <class... Ts>
-   void push(boost::string_view cmd, Ts const&... args)
+   void push(std::string_view cmd, Ts const&... args)
    {
-      using boost::hana::for_each;
-      using boost::hana::make_tuple;
       using resp3::type;
 
       auto constexpr pack_size = sizeof...(Ts);
       detail::add_header(payload_, type::array, 1 + pack_size);
       detail::add_bulk(payload_, cmd);
-      detail::add_bulk(payload_, make_tuple(args...));
+      detail::add_bulk(payload_, std::tie(std::forward<Ts const&>(args)...));
 
-      if (!detail::has_push_response(cmd))
-         ++commands_;
+      check_cmd(cmd);
    }
 
    /** @brief Appends a new command to the end of the request.
@@ -280,7 +292,7 @@ public:
     *  \param end Iterator to the end of the range.
     */
    template <class Key, class ForwardIterator>
-   void push_range(boost::string_view cmd, Key const& key, ForwardIterator begin, ForwardIterator end,
+   void push_range(std::string_view cmd, Key const& key, ForwardIterator begin, ForwardIterator end,
                     typename std::iterator_traits<ForwardIterator>::value_type * = nullptr)
    {
       using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
@@ -298,8 +310,7 @@ public:
       for (; begin != end; ++begin)
 	 detail::add_bulk(payload_, *begin);
 
-      if (!detail::has_push_response(cmd))
-         ++commands_;
+      check_cmd(cmd);
    }
 
    /** @brief Appends a new command to the end of the request.
@@ -320,7 +331,7 @@ public:
     *  \param end Iterator to the end of the range.
     */
    template <class ForwardIterator>
-   void push_range(boost::string_view cmd, ForwardIterator begin, ForwardIterator end,
+   void push_range(std::string_view cmd, ForwardIterator begin, ForwardIterator end,
                    typename std::iterator_traits<ForwardIterator>::value_type * = nullptr)
    {
       using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
@@ -337,8 +348,7 @@ public:
       for (; begin != end; ++begin)
 	 detail::add_bulk(payload_, *begin);
 
-      if (!detail::has_push_response(cmd))
-         ++commands_;
+      check_cmd(cmd);
    }
 
    /** @brief Appends a new command to the end of the request.
@@ -350,7 +360,7 @@ public:
     *  \param range Range to send e.g. and \c std::map.
     */
    template <class Key, class Range>
-   void push_range(boost::string_view cmd, Key const& key, Range const& range,
+   void push_range(std::string_view cmd, Key const& key, Range const& range,
                    decltype(std::begin(range)) * = nullptr)
    {
       using std::begin;
@@ -366,7 +376,7 @@ public:
     *  \param range Range to send e.g. and \c std::map.
     */
    template <class Range>
-   void push_range(boost::string_view cmd, Range const& range,
+   void push_range(std::string_view cmd, Range const& range,
                    decltype(std::begin(range)) * = nullptr)
    {
       using std::begin;
@@ -374,20 +384,20 @@ public:
       push_range(cmd, begin(range), end(range));
    }
 
-   /// Calls std::string::reserve on the internal storage.
-   void reserve(std::size_t new_cap = 0)
-      { payload_.reserve(new_cap); }
-
-   /// Returns a const reference to the config object.
-   [[nodiscard]] auto get_config() const noexcept -> auto const& {return cfg_; }
-
-   /// Returns a reference to the config object.
-   [[nodiscard]] auto get_config() noexcept -> auto& {return cfg_; }
-
 private:
+   void check_cmd(std::string_view cmd)
+   {
+      if (!detail::has_response(cmd))
+         ++commands_;
+
+      if (cmd == "HELLO")
+         has_hello_priority_ = cfg_.hello_with_priority;
+   }
+
+   config cfg_;
    std::pmr::string payload_;
    std::size_t commands_ = 0;
-   config cfg_;
+   bool has_hello_priority_ = false;
 };
 
 } // aedis::resp3

include/aedis/resp3/type.hpp

@@ -50,6 +50,8 @@ enum class type
   /// Simple
   blob_string,
   /// Simple
+  streamed_string,
+  /// Simple
   streamed_string_part,
   /// Invalid
   invalid

include/aedis/src.hpp

@@ -5,7 +5,6 @@
  */
 
 #include <aedis/impl/error.ipp>
-#include <aedis/impl/endpoint.ipp>
 #include <aedis/resp3/impl/request.ipp>
 #include <aedis/resp3/impl/type.ipp>
 #include <aedis/resp3/detail/impl/parser.ipp>

include/aedis/ssl/connection.hpp

@@ -7,17 +7,17 @@
 #ifndef AEDIS_SSL_CONNECTION_HPP
 #define AEDIS_SSL_CONNECTION_HPP
 
-#include <chrono>
-#include <memory>
+#include <aedis/detail/connection_base.hpp>
 
 #include <boost/asio/io_context.hpp>
-#include <aedis/detail/connection_base.hpp>
-#include <aedis/ssl/detail/connection_ops.hpp>
+
+#include <chrono>
+#include <memory>
 
 namespace aedis::ssl {
 
 template <class>
-class connection;
+class basic_connection;
 
 /** \brief A SSL connection to the Redis server.
  *  \ingroup high-level-api
@@ -31,55 +31,44 @@ class connection;
  *
  */
 template <class AsyncReadWriteStream>
-class connection<boost::asio::ssl::stream<AsyncReadWriteStream>> :
+class basic_connection<boost::asio::ssl::stream<AsyncReadWriteStream>> :
    private aedis::detail::connection_base<
       typename boost::asio::ssl::stream<AsyncReadWriteStream>::executor_type,
-      connection<boost::asio::ssl::stream<AsyncReadWriteStream>>> {
+      basic_connection<boost::asio::ssl::stream<AsyncReadWriteStream>>> {
 public:
    /// Type of the next layer
    using next_layer_type = boost::asio::ssl::stream<AsyncReadWriteStream>;
 
    /// Executor type.
    using executor_type = typename next_layer_type::executor_type;
-   using base_type = aedis::detail::connection_base<executor_type, connection<boost::asio::ssl::stream<AsyncReadWriteStream>>>;
 
-   /** \brief Connection configuration parameters.
-    */
-   struct timeouts {
-      /// Timeout of the resolve operation.
-      std::chrono::steady_clock::duration resolve_timeout = std::chrono::seconds{10};
-
-      /// Timeout of the connect operation.
-      std::chrono::steady_clock::duration connect_timeout = std::chrono::seconds{10};
-
-      /// Timeout of the ssl handshake operation.
-      std::chrono::steady_clock::duration handshake_timeout = std::chrono::seconds{10};
-
-      /// Timeout of the resp3 handshake operation.
-      std::chrono::steady_clock::duration resp3_handshake_timeout = std::chrono::seconds{2};
-
-      /// Time interval of ping operations.
-      std::chrono::steady_clock::duration ping_interval = std::chrono::seconds{1};
+   /// Rebinds the socket type to another executor.
+   template <class Executor1>
+   struct rebind_executor
+   {
+      /// The socket type when rebound to the specified executor.
+      using other = basic_connection<boost::asio::ssl::stream<typename AsyncReadWriteStream::template rebind_executor<Executor1>::other>>;
    };
 
+   using base_type = aedis::detail::connection_base<executor_type, basic_connection<boost::asio::ssl::stream<AsyncReadWriteStream>>>;
+
    /// Constructor
    explicit
-   connection(
+   basic_connection(
       executor_type ex,
       boost::asio::ssl::context& ctx,
       std::pmr::memory_resource* resource = std::pmr::get_default_resource())
    : base_type{ex, resource}
    , stream_{ex, ctx}
-   {
-   }
+   { }
 
    /// Constructor
    explicit
-   connection(
+   basic_connection(
       boost::asio::io_context& ioc,
       boost::asio::ssl::context& ctx,
       std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : connection(ioc.get_executor(), ctx, resource)
+   : basic_connection(ioc.get_executor(), ctx, resource)
    { }
 
    /// Returns the associated executor.
@@ -102,13 +91,9 @@ public:
     *  See aedis::connection::async_run for more information.
     */
    template <class CompletionToken = boost::asio::default_completion_token_t<executor_type>>
-   auto
-   async_run(
-      endpoint ep,
-      timeouts ts = timeouts{},
-      CompletionToken token = CompletionToken{})
+   auto async_run(CompletionToken token = CompletionToken{})
    {
-      return base_type::async_run(ep, ts, std::move(token));
+      return base_type::async_run(std::move(token));
    }
 
    /** @brief Executes a command on the Redis server asynchronously.
@@ -147,40 +132,29 @@ public:
    auto cancel(operation op) -> std::size_t
       { return base_type::cancel(op); }
 
+   auto& lowest_layer() noexcept { return stream_.lowest_layer(); }
+
 private:
-   using this_type = connection<next_layer_type>;
+   using this_type = basic_connection<next_layer_type>;
 
    template <class, class> friend class aedis::detail::connection_base;
    template <class, class> friend struct aedis::detail::exec_op;
-   template <class, class> friend struct detail::ssl_connect_with_timeout_op;
-   template <class, class> friend struct aedis::detail::run_op;
-   template <class> friend struct aedis::detail::writer_op;
-   template <class> friend struct aedis::detail::check_idle_op;
-   template <class> friend struct aedis::detail::reader_op;
    template <class, class> friend struct aedis::detail::exec_read_op;
-   template <class> friend struct aedis::detail::ping_op;
+   template <class> friend struct aedis::detail::run_op;
+   template <class> friend struct aedis::detail::writer_op;
+   template <class> friend struct aedis::detail::reader_op;
 
-   auto& lowest_layer() noexcept { return stream_.lowest_layer(); }
    auto is_open() const noexcept { return stream_.next_layer().is_open(); }
    void close() { stream_.next_layer().close(); }
 
-   template <class Timer, class CompletionToken>
-   auto
-   async_connect(
-      boost::asio::ip::tcp::resolver::results_type const& endpoints,
-      timeouts ts,
-      Timer& timer,
-      CompletionToken&& token)
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(detail::ssl_connect_with_timeout_op<this_type, Timer>{this, &endpoints, ts, &timer}, token, stream_);
-   }
-
    next_layer_type stream_;
 };
 
+/** \brief A connection that uses a boost::asio::ssl::stream<boost::asio::ip::tcp::socket>.
+ *  \ingroup high-level-api
+ */
+using connection = basic_connection<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>;
+
 } // aedis::ssl
 
 #endif // AEDIS_SSL_CONNECTION_HPP

include/aedis/ssl/detail/connection_ops.hpp

@@ -1,113 +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)
- */
-
-#ifndef AEDIS_SSL_CONNECTION_OPS_HPP
-#define AEDIS_SSL_CONNECTION_OPS_HPP
-
-#include <array>
-
-#include <boost/assert.hpp>
-#include <boost/system.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
-#include <boost/asio/yield.hpp>
-
-namespace aedis::ssl::detail
-{
-
-template <class Stream>
-struct handshake_op {
-   Stream* stream;
-   aedis::detail::conn_timer_t<typename Stream::executor_type>* timer;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , boost::system::error_code ec1 = {}
-                  , boost::system::error_code ec2 = {})
-   {
-      reenter (coro)
-      {
-         yield
-         boost::asio::experimental::make_parallel_group(
-            [this](auto token)
-            {
-               return stream->async_handshake(boost::asio::ssl::stream_base::client, token);
-            },
-            [this](auto token) { return timer->async_wait(token);}
-         ).async_wait(
-            boost::asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(boost::asio::error::operation_aborted);
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: self.complete(ec1); return;
-            case 1:
-            {
-               BOOST_ASSERT_MSG(!ec2, "handshake_op: Incompatible state.");
-               self.complete(error::ssl_handshake_timeout);
-               return;
-            }
-
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <
-   class Stream,
-   class CompletionToken
-   >
-auto async_handshake(
-      Stream& stream,
-      aedis::detail::conn_timer_t<typename Stream::executor_type>& timer,
-      CompletionToken&& token)
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code)
-      >(handshake_op<Stream>{&stream, &timer}, token, stream, timer);
-}
-
-template <class Conn, class Timer>
-struct ssl_connect_with_timeout_op {
-   Conn* conn = nullptr;
-   boost::asio::ip::tcp::resolver::results_type const* endpoints = nullptr;
-   typename Conn::timeouts ts;
-   Timer* timer = nullptr;
-   boost::asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , boost::asio::ip::tcp::endpoint const& = {})
-   {
-      reenter (coro)
-      {
-         timer->expires_after(ts.connect_timeout);
-         yield
-         aedis::detail::async_connect(
-            conn->lowest_layer(), *timer, *endpoints, std::move(self));
-         AEDIS_CHECK_OP0();
-
-         timer->expires_after(ts.handshake_timeout);
-         yield
-         async_handshake(conn->next_layer(), *timer, std::move(self));
-         AEDIS_CHECK_OP0();
-         self.complete({});
-      }
-   }
-};
-
-} // aedis::ssl::detail
- 
-#include <boost/asio/unyield.hpp>
-#endif // AEDIS_SSL_CONNECTION_OPS_HPP

tests/common.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include <chrono>
+
+namespace net = boost::asio;
+using endpoints = net::ip::tcp::resolver::results_type;
+
+auto
+resolve(
+   std::string const& host = "127.0.0.1",
+   std::string const& port = "6379") -> endpoints
+{
+   net::io_context ioc;
+   net::ip::tcp::resolver resv{ioc};
+   return resv.resolve(host, port);
+}
+
+#ifdef BOOST_ASIO_HAS_CO_AWAIT
+inline
+auto redir(boost::system::error_code& ec)
+   { return net::redirect_error(net::use_awaitable, ec); }
+#endif // BOOST_ASIO_HAS_CO_AWAIT

tests/conn_connect.cpp

@@ -1,164 +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 <iostream>
-#include <boost/asio.hpp>
-#include <boost/system/errc.hpp>
-
-#define BOOST_TEST_MODULE low level
-#include <boost/test/included/unit_test.hpp>
-
-#include <aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
-using error_code = boost::system::error_code;
-
-bool is_host_not_found(error_code ec)
-{
-   if (ec == net::error::netdb_errors::host_not_found) return true;
-   if (ec == net::error::netdb_errors::host_not_found_try_again) return true;
-   return false;
-}
-
-error_code test_async_run(endpoint ep, connection::timeouts cfg = {})
-{
-   net::io_context ioc;
-   connection db{ioc};
-   error_code ret;
-   db.async_run(ep, cfg, [&](auto ec) { ret = ec; });
-   ioc.run();
-   return ret;
-}
-
-BOOST_AUTO_TEST_CASE(resolve_bad_host)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "Atibaia";
-   ep.port = "6379";
-
-   connection::timeouts cfg;
-   cfg.resolve_timeout = std::chrono::seconds{100};
-   auto const ec = test_async_run(ep, cfg);
-
-   BOOST_TEST(is_host_not_found(ec));
-}
-
-BOOST_AUTO_TEST_CASE(resolve_with_timeout)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "Atibaia";
-   ep.port = "6379";
-
-   connection::timeouts cfg;
-   // Low-enough to cause a timeout always.
-   cfg.resolve_timeout = std::chrono::milliseconds{1};
-   auto const ec = test_async_run(ep, cfg);
-   BOOST_CHECK_EQUAL(ec, aedis::error::resolve_timeout);
-}
-
-BOOST_AUTO_TEST_CASE(connect_bad_port)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "127.0.0.1";
-   ep.port = "1";
-
-   connection::timeouts cfg;
-   cfg.connect_timeout = std::chrono::seconds{100};
-   auto const ec = test_async_run(ep, cfg);
-   BOOST_CHECK_EQUAL(ec, net::error::basic_errors::connection_refused);
-}
-
-BOOST_AUTO_TEST_CASE(connect_with_timeout)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "example.com";
-   ep.port = "1";
-
-   connection::timeouts cfg;
-   cfg.connect_timeout = std::chrono::milliseconds{1};
-   auto const ec = test_async_run(ep, cfg);
-   BOOST_CHECK_EQUAL(ec, aedis::error::connect_timeout);
-}
-
-BOOST_AUTO_TEST_CASE(bad_hello_response)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   // Succeeds with the tcp connection but fails the hello.
-   endpoint ep;
-   ep.host = "google.com";
-   ep.port = "80";
-
-   auto const ec = test_async_run(ep);
-   BOOST_CHECK_EQUAL(ec, aedis::error::invalid_data_type);
-}
-
-BOOST_AUTO_TEST_CASE(plain_conn_on_tls_endpoint)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "google.com";
-   ep.port = "443";
-
-   auto const ec = test_async_run(ep);
-   BOOST_TEST(!!ec);
-}
-
-auto auth_fail_error(boost::system::error_code ec)
-{
-   return ec == aedis::error::resp3_handshake_error ||
-          ec == aedis::error::exec_timeout;
-}
-
-BOOST_AUTO_TEST_CASE(auth_fail)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   // Should cause an error in the authentication as our redis server
-   // has no authentication configured.
-   endpoint ep;
-   ep.host = "127.0.0.1";
-   ep.port = "6379";
-   ep.username = "caboclo-do-mato";
-   ep.password = "jabuticaba";
-
-   auto const ec = test_async_run(ep);
-   BOOST_TEST(auth_fail_error(ec));
-}
-
-auto wrong_role_error(boost::system::error_code ec)
-{
-   return ec == aedis::error::unexpected_server_role ||
-          ec == aedis::error::exec_timeout;
-}
-
-BOOST_AUTO_TEST_CASE(wrong_role)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   // Should cause an error in the authentication as our redis server
-   // has no authentication configured.
-   endpoint ep;
-   ep.host = "127.0.0.1";
-   ep.port = "6379";
-   ep.role = "errado";
-
-   auto const ec = test_async_run(ep);
-   BOOST_TEST(wrong_role_error(ec));
-}

tests/conn_echo_stress.cpp

@@ -8,26 +8,20 @@
 #include <boost/asio.hpp>
 #ifdef BOOST_ASIO_HAS_CO_AWAIT
 #include <boost/system/errc.hpp>
-
 #define BOOST_TEST_MODULE low level
 #include <boost/test/included/unit_test.hpp>
-
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
+#include "../examples/common/common.hpp"
 
 namespace net = boost::asio;
-
-using aedis::resp3::request;
+namespace resp3 = aedis::resp3;
+using error_code = boost::system::error_code;
 using aedis::operation;
 using aedis::adapt;
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
-using error_code = boost::system::error_code;
 
-#include <boost/asio/experimental/awaitable_operators.hpp>
-using namespace net::experimental::awaitable_operators;
-
-net::awaitable<void> push_consumer(std::shared_ptr<connection> conn, int expected)
+auto push_consumer(std::shared_ptr<connection> conn, int expected) -> net::awaitable<void>
 {
    int c = 0;
    for (;;) {
@@ -36,29 +30,31 @@ net::awaitable<void> push_consumer(std::shared_ptr<connection> conn, int expecte
          break;
    }
 
-   request req;
+   resp3::request req;
+   req.push("HELLO", 3);
    req.push("QUIT");
-   co_await conn->async_exec(req, adapt(), net::use_awaitable);
+   co_await conn->async_exec(req, adapt());
 }
 
 auto echo_session(std::shared_ptr<connection> conn, std::string id, int n) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
 
-   request req;
-   std::tuple<std::string> resp;
+   resp3::request req;
+   std::tuple<aedis::ignore, std::string> resp;
 
    for (auto i = 0; i < n; ++i) {
       auto const msg = id + "/" + std::to_string(i);
       //std::cout << msg << std::endl;
+      req.push("HELLO", 3);
       req.push("PING", msg);
       req.push("SUBSCRIBE", "channel");
       boost::system::error_code ec;
-      co_await conn->async_exec(req, adapt(resp), net::redirect_error(net::use_awaitable, ec));
-      BOOST_TEST(!ec);
-      BOOST_CHECK_EQUAL(msg, std::get<0>(resp));
+      co_await conn->async_exec(req, adapt(resp), redir(ec));
+      BOOST_CHECK_EQUAL(ec, boost::system::error_code{});
+      BOOST_CHECK_EQUAL(msg, std::get<1>(resp));
       req.clear();
-      std::get<0>(resp).clear();
+      std::get<1>(resp).clear();
    }
 }
 
@@ -67,8 +63,8 @@ auto async_echo_stress() -> net::awaitable<void>
    auto ex = co_await net::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
 
-   int const sessions = 1000;
-   int const msgs = 100;
+   int const sessions = 500;
+   int const msgs = 1000;
    int total = sessions * msgs;
 
    net::co_spawn(ex, push_consumer(conn, total), net::detached);
@@ -76,15 +72,13 @@ auto async_echo_stress() -> net::awaitable<void>
    for (int i = 0; i < sessions; ++i) 
       net::co_spawn(ex, echo_session(conn, std::to_string(i), msgs), net::detached);
 
-   endpoint ep{"127.0.0.1", "6379"};
-   co_await conn->async_run(ep, {}, net::use_awaitable);
+   co_await connect(conn, "127.0.0.1", "6379");
+   co_await conn->async_run();
 }
 
 BOOST_AUTO_TEST_CASE(echo_stress)
 {
-   net::io_context ioc;
-   net::co_spawn(ioc.get_executor(), async_echo_stress(), net::detached);
-   ioc.run();
+   run(async_echo_stress());
 }
 
 #else

tests/conn_exec.cpp

@@ -14,32 +14,93 @@
 #include <aedis.hpp>
 #include <aedis/src.hpp>
 
+#include "common.hpp"
+
+// TODO: Test whether HELLO won't be inserted passt commands that have
+// been already writen.
+
 namespace net = boost::asio;
-
-using aedis::resp3::request;
-using aedis::adapt;
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
+namespace resp3 = aedis::resp3;
 using error_code = boost::system::error_code;
+using connection = aedis::connection;
+using aedis::adapt;
 
-#ifdef BOOST_ASIO_HAS_CO_AWAIT
-#include <boost/asio/experimental/awaitable_operators.hpp>
-using namespace net::experimental::awaitable_operators;
-#endif
+BOOST_AUTO_TEST_CASE(hello_priority)
+{
+   resp3::request req1;
+   req1.get_config().coalesce = false;
+   req1.push("PING", "req1");
+
+   resp3::request req2;
+   req2.get_config().coalesce = false;
+   req2.get_config().hello_with_priority = false;
+   req2.push("HELLO", 3);
+   req2.push("PING", "req2");
+   req2.push("QUIT");
+
+   resp3::request req3;
+   req3.get_config().coalesce = false;
+   req3.get_config().hello_with_priority = true;
+   req3.push("HELLO", 3);
+   req3.push("PING", "req3");
+
+   net::io_context ioc;
+
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
+   bool seen1 = false;
+   bool seen2 = false;
+   bool seen3 = false;
+
+   conn.async_exec(req1, adapt(), [&](auto ec, auto){
+      std::cout << "bbb" << std::endl;
+      BOOST_TEST(!ec);
+      BOOST_TEST(!seen2);
+      BOOST_TEST(seen3);
+      seen1 = true;
+   });
+   conn.async_exec(req2, adapt(), [&](auto ec, auto){
+      std::cout << "ccc" << std::endl;
+      BOOST_TEST(!ec);
+      BOOST_TEST(seen1);
+      BOOST_TEST(seen3);
+      seen2 = true;
+   });
+   conn.async_exec(req3, adapt(), [&](auto ec, auto){
+      std::cout << "ddd" << std::endl;
+      BOOST_TEST(!ec);
+      BOOST_TEST(!seen1);
+      BOOST_TEST(!seen2);
+      seen3 = true;
+   });
+
+   conn.async_run([](auto ec){
+      BOOST_TEST(!ec);
+   });
+
+   ioc.run();
+}
 
 BOOST_AUTO_TEST_CASE(wrong_response_data_type)
 {
-   request req;
+   resp3::request req;
+   req.push("HELLO", 3);
    req.push("QUIT");
 
    // Wrong data type.
-   std::tuple<int> resp;
+   std::tuple<aedis::ignore, int> resp;
    net::io_context ioc;
-   auto db = std::make_shared<connection>(ioc);
-   db->async_exec(req, adapt(resp), [](auto ec, auto){
+
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
+   conn.async_exec(req, adapt(resp), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, aedis::error::not_a_number);
    });
-   db->async_run({"127.0.0.1", "6379"}, {}, [](auto ec){
+   conn.async_run([](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
@@ -48,44 +109,16 @@ BOOST_AUTO_TEST_CASE(wrong_response_data_type)
 
 BOOST_AUTO_TEST_CASE(cancel_request_if_not_connected)
 {
-   request req;
+   resp3::request req;
    req.get_config().cancel_if_not_connected = true;
+   req.push("HELLO", 3);
    req.push("PING");
 
    net::io_context ioc;
-   auto db = std::make_shared<connection>(ioc);
-   db->async_exec(req, adapt(), [](auto ec, auto){
+   auto conn = std::make_shared<connection>(ioc);
+   conn->async_exec(req, adapt(), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, aedis::error::not_connected);
    });
 
    ioc.run();
 }
-
-BOOST_AUTO_TEST_CASE(request_retry)
-{
-   request req1;
-   req1.get_config().cancel_on_connection_lost = true;
-   req1.push("CLIENT", "PAUSE", 7000);
-
-   request req2;
-   req2.get_config().cancel_on_connection_lost = false;
-   req2.get_config().retry = false;
-   req2.push("PING");
-
-   net::io_context ioc;
-   auto db = std::make_shared<connection>(ioc);
-
-   db->async_exec(req1, adapt(), [](auto ec, auto){
-      BOOST_TEST(!ec);
-   });
-
-   db->async_exec(req2, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-   });
-
-   db->async_run({"127.0.0.1", "6379"}, {}, [](auto ec){
-      BOOST_CHECK_EQUAL(ec, aedis::error::idle_timeout);
-   });
-
-   ioc.run();
-}

tests/conn_exec_cancel.cpp

@@ -8,47 +8,47 @@
 #include <boost/asio.hpp>
 #ifdef BOOST_ASIO_HAS_CO_AWAIT
 #include <boost/system/errc.hpp>
-
+#include <boost/asio/experimental/awaitable_operators.hpp>
 #define BOOST_TEST_MODULE low level
 #include <boost/test/included/unit_test.hpp>
-
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
+#include "../examples/common/common.hpp"
+
+// NOTE1: Sends hello separately. I have observed that if hello and
+// blpop are sent toguether, Redis will send the response of hello
+// right away, not waiting for blpop. That is why we have to send it
+// separately here.
 
 namespace net = boost::asio;
-
-using aedis::resp3::request;
+namespace resp3 = aedis::resp3;
+using error_code = boost::system::error_code;
+using namespace net::experimental::awaitable_operators;
 using aedis::operation;
 using aedis::adapt;
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
-using error_code = boost::system::error_code;
 
-#include <boost/asio/experimental/awaitable_operators.hpp>
-using namespace net::experimental::awaitable_operators;
-
-auto async_run(std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto async_ignore_explicit_cancel_of_req_written() -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
 
-   connection::timeouts tms;
-   tms.ping_interval = std::chrono::seconds{10};
-   endpoint ep{"127.0.0.1", "6379"};
-   boost::system::error_code ec;
-   co_await conn->async_run(ep, tms, net::redirect_error(net::use_awaitable, ec));
-   BOOST_TEST(!ec);
-}
+   auto conn = std::make_shared<connection>(ex);
+   co_await connect(conn, "127.0.0.1", "6379");
 
-auto async_cancel_exec(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
-   auto ex = co_await net::this_coro::executor;
+   conn->async_run([conn](auto ec) {
+      BOOST_TEST(!ec);
+   });
 
    net::steady_timer st{ex};
    st.expires_after(std::chrono::seconds{1});
 
-   boost::system::error_code ec1;
+   // See NOTE1.
+   resp3::request req0;
+   req0.get_config().coalesce = false;
+   req0.push("HELLO", 3);
+   std::ignore = co_await conn->async_exec(req0, adapt(), net::use_awaitable);
 
-   request req1;
+   resp3::request req1;
    req1.get_config().coalesce = false;
    req1.push("BLPOP", "any", 3);
 
@@ -57,22 +57,23 @@ auto async_cancel_exec(std::shared_ptr<connection> conn) -> net::awaitable<void>
       BOOST_TEST(!ec);
    });
 
-   request req2;
+   resp3::request req2;
    req2.get_config().coalesce = false;
    req2.push("PING", "second");
 
    // Should be canceled.
-   conn->async_exec(req1, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
+   conn->async_exec(req2, adapt(), [](auto ec, auto){
+      BOOST_CHECK_EQUAL(ec, net::error::basic_errors::operation_aborted);
    });
 
    // Will complete while BLPOP is pending.
+   boost::system::error_code ec1;
    co_await st.async_wait(net::redirect_error(net::use_awaitable, ec1));
    conn->cancel(operation::exec);
 
    BOOST_TEST(!ec1);
 
-   request req3;
+   resp3::request req3;
    req3.push("QUIT");
 
    // Test whether the connection remains usable after a call to
@@ -82,61 +83,98 @@ auto async_cancel_exec(std::shared_ptr<connection> conn) -> net::awaitable<void>
    BOOST_TEST(!ec1);
 }
 
-BOOST_AUTO_TEST_CASE(cancel_exec_with_timer)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-   net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc.get_executor(), async_run(conn), net::detached);
-   net::co_spawn(ioc.get_executor(), async_cancel_exec(conn), net::detached);
-   ioc.run();
-}
-
-auto async_ignore_cancel_of_written_req(std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto ignore_implicit_cancel_of_req_written() -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   co_await connect(conn, "127.0.0.1", "6379");
+
+   // Calls async_run separately from the group of ops below to avoid
+   // having it canceled when the timer fires.
+   conn->async_run([conn](auto ec) {
+      BOOST_CHECK_EQUAL(ec, net::error::basic_errors::operation_aborted);
+   });
+
+   // See NOTE1.
+   resp3::request req0;
+   req0.get_config().coalesce = false;
+   req0.push("HELLO", 3);
+   std::ignore = co_await conn->async_exec(req0, adapt(), net::use_awaitable);
+
+   // Will be cancelled after it has been written but before the
+   // response arrives.
+   resp3::request req1;
+   req1.get_config().coalesce = false;
+   req1.push("BLPOP", "any", 3);
+
+   // Will be cancelled before it is written.
+   resp3::request req2;
+   req2.get_config().coalesce = false;
+   req2.get_config().cancel_on_connection_lost = true;
+   req2.push("PING");
 
    net::steady_timer st{ex};
    st.expires_after(std::chrono::seconds{1});
 
-   net::steady_timer st2{ex};
-   st2.expires_after(std::chrono::seconds{3});
-
    boost::system::error_code ec1, ec2, ec3;
-
-   request req1; // Will be cancelled after it has been written.
-   req1.get_config().coalesce = false;
-   req1.push("BLPOP", "any", 3);
-
-   request req2; // Will be cancelled.
-   req2.push("PING");
-
    co_await (
-      conn->async_exec(req1, adapt(), net::redirect_error(net::use_awaitable, ec1)) ||
-      conn->async_exec(req2, adapt(), net::redirect_error(net::use_awaitable, ec2)) ||
-      st.async_wait(net::redirect_error(net::use_awaitable, ec3))
+      conn->async_exec(req1, adapt(), redir(ec1)) ||
+      conn->async_exec(req2, adapt(), redir(ec2)) ||
+      st.async_wait(redir(ec3))
    );
 
-   BOOST_TEST(!ec1);
-   BOOST_CHECK_EQUAL(ec2, boost::asio::error::basic_errors::operation_aborted);
+   BOOST_CHECK_EQUAL(ec1, net::error::basic_errors::operation_aborted);
+   BOOST_CHECK_EQUAL(ec2, net::error::basic_errors::operation_aborted);
    BOOST_TEST(!ec3);
-
-   request req3;
-   req3.push("PING");
-   req3.push("QUIT");
-   co_await conn->async_exec(req3, adapt(), net::redirect_error(net::use_awaitable, ec1));
-   BOOST_TEST(!ec1);
 }
 
-BOOST_AUTO_TEST_CASE(ignore_cancel_of_written_req)
+auto cancel_of_req_written_on_run_canceled() -> net::awaitable<void>
 {
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-   net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc.get_executor(), async_run(conn), net::detached);
-   net::co_spawn(ioc.get_executor(), async_ignore_cancel_of_written_req(conn), net::detached);
-   ioc.run();
+   resp3::request req0;
+   req0.get_config().coalesce = false;
+   req0.push("HELLO", 3);
+
+   resp3::request req1;
+   req1.get_config().cancel_on_connection_lost = true;
+   req1.get_config().cancel_if_unresponded = true;
+   req1.push("BLPOP", "any", 0);
+
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   co_await connect(conn, "127.0.0.1", "6379");
+
+   net::steady_timer st{ex};
+   st.expires_after(std::chrono::seconds{1});
+
+   boost::system::error_code ec0, ec1, ec2, ec3;
+   co_await (
+      conn->async_exec(req0, adapt(), redir(ec0)) &&
+      (conn->async_exec(req1, adapt(), redir(ec1)) ||
+      conn->async_run(redir(ec2)) ||
+      st.async_wait(redir(ec3)))
+   );
+
+   BOOST_TEST(!ec0);
+   BOOST_CHECK_EQUAL(ec1, net::error::basic_errors::operation_aborted);
+   BOOST_CHECK_EQUAL(ec2, net::error::basic_errors::operation_aborted);
+   BOOST_TEST(!ec3);
 }
+
+BOOST_AUTO_TEST_CASE(test_ignore_explicit_cancel_of_req_written)
+{
+   run(async_ignore_explicit_cancel_of_req_written());
+}
+
+BOOST_AUTO_TEST_CASE(test_ignore_implicit_cancel_of_req_written)
+{
+   run(ignore_implicit_cancel_of_req_written());
+}
+
+BOOST_AUTO_TEST_CASE(test_cancel_of_req_written_on_run_canceled)
+{
+   run(cancel_of_req_written_on_run_canceled());
+}
+
 #else
 int main(){}
 #endif

tests/conn_exec_retry.cpp

@@ -0,0 +1,148 @@
+/* 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 <iostream>
+#include <boost/asio.hpp>
+#include <boost/system/errc.hpp>
+
+#define BOOST_TEST_MODULE low level
+#include <boost/test/included/unit_test.hpp>
+
+#include <aedis.hpp>
+#include <aedis/src.hpp>
+
+#include "common.hpp"
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using error_code = boost::system::error_code;
+using connection = aedis::connection;
+using aedis::adapt;
+
+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 third request to complete with error
+      // although it has cancel_on_connection_lost = false. The reason
+      // being is has already been written so
+      // cancel_on_connection_lost does not apply.
+      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 thrid request to not complete with error
+      // since it has cancel_if_unresponded = true and cancellation commes
+      // after it was written.
+      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){
+      // The first cacellation.
+      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
+      conn.reset_stream();
+
+      // Reconnects and runs again to test req3.
+      net::connect(conn.next_layer(), endpoints);
+      conn.async_run([&](auto ec){
+         std::cout << ec.message() << std::endl;
+         BOOST_TEST(!ec);
+      });
+   });
+
+   ioc.run();
+}

tests/conn_push.cpp

@@ -6,6 +6,7 @@
 
 #include <iostream>
 #include <boost/asio.hpp>
+#ifdef BOOST_ASIO_HAS_CO_AWAIT
 #include <boost/system/errc.hpp>
 #include <boost/asio/experimental/as_tuple.hpp>
 
@@ -14,94 +15,83 @@
 
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
 
 namespace net = boost::asio;
 
 using aedis::resp3::request;
 using aedis::adapt;
-using aedis::endpoint;
 using aedis::operation;
-using connection = aedis::connection<>;
+using connection = aedis::connection;
 using error_code = boost::system::error_code;
 using net::experimental::as_tuple;
 
 BOOST_AUTO_TEST_CASE(push_filtered_out)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
 
    request req;
+   req.push("HELLO", 3);
    req.push("PING");
    req.push("SUBSCRIBE", "channel");
    req.push("QUIT");
 
-   std::tuple<std::string, std::string> resp;
-   conn->async_exec(req, adapt(resp), [](auto ec, auto){
+   std::tuple<aedis::ignore, std::string, std::string> resp;
+   conn.async_exec(req, adapt(resp), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
 
-   conn->async_receive(adapt(), [](auto ec, auto){
+   conn.async_receive(adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [conn](auto ec){
+   conn.async_run([](auto ec){
       BOOST_TEST(!ec);
    });
 
    ioc.run();
 
-   BOOST_CHECK_EQUAL(std::get<0>(resp), "PONG");
-   BOOST_CHECK_EQUAL(std::get<1>(resp), "OK");
+   BOOST_CHECK_EQUAL(std::get<1>(resp), "PONG");
+   BOOST_CHECK_EQUAL(std::get<2>(resp), "OK");
 }
 
-// Checks whether we get idle timeout when no push reader is set.
-void test_missing_push_reader1(bool coalesce)
+void receive_wrong_syntax(request const& req)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
 
-   request req{{false, coalesce}};
-   req.get_config().cancel_on_connection_lost = true;
-   req.push("SUBSCRIBE", "channel");
-
-   conn->async_exec(req, adapt(), [](auto ec, auto){
+   conn.async_exec(req, adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [conn](auto ec){
-      BOOST_CHECK_EQUAL(ec, aedis::error::idle_timeout);
+   conn.async_run([](auto ec){
+      BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
-   ioc.run();
-}
-
-void test_missing_push_reader2(request const& req)
-{
-   net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-
-   conn->async_exec(req, adapt(), [](auto ec, auto){
+   conn.async_receive(adapt(), [&](auto ec, auto){
       BOOST_TEST(!ec);
-   });
-
-   conn->async_run({"127.0.0.1", "6379"}, {}, [](auto ec){
-      BOOST_CHECK_EQUAL(ec, aedis::error::idle_timeout);
+      conn.cancel(aedis::operation::run);
    });
 
    ioc.run();
 }
 
 #ifdef BOOST_ASIO_HAS_CO_AWAIT
-net::awaitable<void> push_consumer1(std::shared_ptr<connection> conn, bool& push_received)
+net::awaitable<void> push_consumer1(connection& conn, bool& push_received)
 {
    {
-      auto [ec, ev] = co_await conn->async_receive(adapt(), as_tuple(net::use_awaitable));
+      auto [ec, ev] = co_await conn.async_receive(adapt(), as_tuple(net::use_awaitable));
       BOOST_TEST(!ec);
    }
 
    {
-      auto [ec, ev] = co_await conn->async_receive(adapt(), as_tuple(net::use_awaitable));
-      BOOST_CHECK_EQUAL(ec, boost::asio::experimental::channel_errc::channel_cancelled);
+      auto [ec, ev] = co_await conn.async_receive(adapt(), as_tuple(net::use_awaitable));
+      BOOST_CHECK_EQUAL(ec, net::experimental::channel_errc::channel_cancelled);
    }
 
    push_received = true;
@@ -110,7 +100,7 @@ net::awaitable<void> push_consumer1(std::shared_ptr<connection> conn, bool& push
 struct adapter_error {
    void
    operator()(
-      std::size_t, aedis::resp3::node<boost::string_view> const&, boost::system::error_code& ec)
+      std::size_t, aedis::resp3::node<std::string_view> const&, boost::system::error_code& ec)
    {
       ec = aedis::error::incompatible_size;
    }
@@ -127,22 +117,25 @@ struct adapter_error {
 BOOST_AUTO_TEST_CASE(test_push_adapter)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
 
    request req;
+   req.push("HELLO", 3);
    req.push("PING");
    req.push("SUBSCRIBE", "channel");
    req.push("PING");
 
-   conn->async_receive(adapter_error{}, [](auto ec, auto) {
+   conn.async_receive(adapter_error{}, [](auto ec, auto) {
       BOOST_CHECK_EQUAL(ec, aedis::error::incompatible_size);
    });
 
-   conn->async_exec(req, adapt(), [](auto ec, auto){
-      BOOST_CHECK_EQUAL(ec, boost::asio::experimental::error::channel_errors::channel_cancelled);
+   conn.async_exec(req, adapt(), [](auto ec, auto){
+      BOOST_CHECK_EQUAL(ec, net::experimental::error::channel_errors::channel_cancelled);
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [](auto ec){
+   conn.async_run([](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
@@ -155,19 +148,23 @@ BOOST_AUTO_TEST_CASE(test_push_adapter)
 void test_push_is_received1(bool coalesce)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
 
    request req{{false, coalesce}};
+   req.push("HELLO", 3);
    req.push("SUBSCRIBE", "channel");
    req.push("QUIT");
 
-   conn->async_exec(req, adapt(), [](auto ec, auto){
+   conn.async_exec(req, adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [conn](auto ec){
+   conn.async_run([&](auto ec){
       BOOST_TEST(!ec);
-      conn->cancel(operation::receive);
+      conn.cancel(operation::receive);
    });
 
    bool push_received = false;
@@ -184,6 +181,7 @@ void test_push_is_received1(bool coalesce)
 void test_push_is_received2(bool coalesce)
 {
    request req1{{false, coalesce}};
+   req1.push("HELLO", 3);
    req1.push("PING", "Message1");
 
    request req2{{false, coalesce}};
@@ -195,21 +193,23 @@ void test_push_is_received2(bool coalesce)
 
    net::io_context ioc;
 
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
 
    auto handler =[](auto ec, auto...)
    {
       BOOST_TEST(!ec);
    };
 
-   conn->async_exec(req1, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req3, adapt(), handler);
+   conn.async_exec(req1, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req3, adapt(), handler);
 
-   endpoint ep{"127.0.0.1", "6379"};
-   conn->async_run(ep, {}, [conn](auto ec) {
+   conn.async_run([&](auto ec) {
       BOOST_TEST(!ec);
-      conn->cancel(operation::receive);
+      conn.cancel(operation::receive);
    });
 
    bool push_received = false;
@@ -223,10 +223,10 @@ void test_push_is_received2(bool coalesce)
    BOOST_TEST(push_received);
 }
 
-net::awaitable<void> push_consumer3(std::shared_ptr<connection> conn)
+net::awaitable<void> push_consumer3(connection& conn)
 {
    for (;;)
-      co_await conn->async_receive(adapt(), net::use_awaitable);
+      co_await conn.async_receive(adapt(), net::use_awaitable);
 }
 
 // Test many subscribe requests.
@@ -250,24 +250,26 @@ void test_push_many_subscribes(bool coalesce)
    };
 
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   conn->async_exec(req0, adapt(), handler);
-   conn->async_exec(req1, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req1, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req1, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req1, adapt(), handler);
-   conn->async_exec(req2, adapt(), handler);
-   conn->async_exec(req3, adapt(), handler);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
 
-   endpoint ep{"127.0.0.1", "6379"};
-   conn->async_run(ep, {}, [conn](auto ec) {
+   conn.async_exec(req0, adapt(), handler);
+   conn.async_exec(req1, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req1, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req1, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req1, adapt(), handler);
+   conn.async_exec(req2, adapt(), handler);
+   conn.async_exec(req3, adapt(), handler);
+
+   conn.async_run([&](auto ec) {
       BOOST_TEST(!ec);
-      conn->cancel(operation::receive);
+      conn.cancel(operation::receive);
    });
 
    net::co_spawn(ioc.get_executor(), push_consumer3(conn), net::detached);
@@ -293,38 +295,33 @@ BOOST_AUTO_TEST_CASE(many_subscribers)
 }
 #endif
 
-BOOST_AUTO_TEST_CASE(missing_reader1_coalesce)
-{
-   test_missing_push_reader1(true);
-}
-
-BOOST_AUTO_TEST_CASE(missing_reader1_no_coalesce)
-{
-   test_missing_push_reader1(false);
-}
-
-BOOST_AUTO_TEST_CASE(missing_reader2a)
+BOOST_AUTO_TEST_CASE(receive_wrong_syntax1)
 {
    request req1{{false}};
+   req1.push("HELLO", 3);
    req1.push("PING", "Message");
    req1.push("SUBSCRIBE"); // Wrong command synthax.
 
    req1.get_config().coalesce = true;
-   test_missing_push_reader2(req1);
+   receive_wrong_syntax(req1);
 
    req1.get_config().coalesce = false;
-   test_missing_push_reader2(req1);
+   receive_wrong_syntax(req1);
 }
 
-BOOST_AUTO_TEST_CASE(missing_reader2b)
+BOOST_AUTO_TEST_CASE(receice_wrong_syntay2)
 {
    request req2{{false}};
+   req2.push("HELLO", 3);
    req2.push("SUBSCRIBE"); // Wrong command syntax.
 
    req2.get_config().coalesce = true;
-   test_missing_push_reader2(req2);
+   receive_wrong_syntax(req2);
 
    req2.get_config().coalesce = false;
-   test_missing_push_reader2(req2);
+   receive_wrong_syntax(req2);
 }
 
+#else
+int main() {}
+#endif

tests/conn_quit.cpp

@@ -13,13 +13,13 @@
 
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
 
 namespace net = boost::asio;
 
 using aedis::adapt;
-using aedis::endpoint;
 using aedis::resp3::request;
-using connection = aedis::connection<>;
+using connection = aedis::connection;
 using error_code = boost::system::error_code;
 using operation = aedis::operation;
 
@@ -27,34 +27,40 @@ using operation = aedis::operation;
 BOOST_AUTO_TEST_CASE(test_quit_no_coalesce)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
 
-   request req1{{false, false}};
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
+   request req1;
+   req1.get_config().cancel_on_connection_lost = false;
+   req1.get_config().coalesce = false;
    req1.push("PING");
 
-   request req2{{false, false}};
+   request req2;
+   req2.get_config().cancel_on_connection_lost = false;
+   req2.get_config().coalesce = false;
    req2.push("QUIT");
 
-   conn->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
-   conn->async_exec(req2, adapt(), [](auto ec, auto) {
+   conn.async_exec(req2, adapt(), [](auto ec, auto) {
       BOOST_TEST(!ec);
    });
-   conn->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
-   conn->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
          BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
-   conn->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
-   endpoint ep{"127.0.0.1", "6379"};
-   conn->async_run(ep, {}, [conn](auto ec){
+   conn.async_run([&](auto ec){
       BOOST_TEST(!ec);
-      conn->cancel(operation::exec);
+      conn.cancel(operation::exec);
    });
 
    ioc.run();
@@ -63,15 +69,20 @@ BOOST_AUTO_TEST_CASE(test_quit_no_coalesce)
 void test_quit2(bool coalesce)
 {
    request req{{false, coalesce}};
+   req.push("HELLO", 3);
    req.push("QUIT");
 
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   conn->async_exec(req, adapt(), [](auto ec, auto) {
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
+
+   conn.async_exec(req, adapt(), [](auto ec, auto) {
       BOOST_TEST(!ec);
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [](auto ec) {
+   conn.async_run([](auto ec) {
       BOOST_TEST(!ec);
    });
 

tests/conn_quit_coalesce.cpp

@@ -13,20 +13,22 @@
 
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
 
 namespace net = boost::asio;
 
 using aedis::adapt;
-using aedis::endpoint;
 using aedis::resp3::request;
-using connection = aedis::connection<>;
+using connection = aedis::connection;
 using error_code = boost::system::error_code;
 using operation = aedis::operation;
 
 BOOST_AUTO_TEST_CASE(test_quit_coalesce)
 {
    net::io_context ioc;
-   auto db = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
 
    request req1{{false, true}};
    req1.push("PING");
@@ -34,23 +36,22 @@ BOOST_AUTO_TEST_CASE(test_quit_coalesce)
    request req2{{false, true}};
    req2.push("QUIT");
 
-   db->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
-   db->async_exec(req2, adapt(), [](auto ec, auto){
+   conn.async_exec(req2, adapt(), [](auto ec, auto){
       BOOST_TEST(!ec);
    });
-   db->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, net::error::misc_errors::eof);
    });
-   db->async_exec(req1, adapt(), [](auto ec, auto){
+   conn.async_exec(req1, adapt(), [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
-   endpoint ep{"127.0.0.1", "6379"};
-   db->async_run(ep, {}, [db](auto ec){
+   conn.async_run([&](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
-      db->cancel(operation::exec);
+      conn.cancel(operation::exec);
    });
 
    ioc.run();

tests/conn_reconnect.cpp

@@ -13,35 +13,40 @@
 
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
+#include "../examples/common/common.hpp"
 
 namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
 
-using aedis::resp3::request;
 using aedis::adapt;
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
 using error_code = boost::system::error_code;
 
 #include <boost/asio/experimental/awaitable_operators.hpp>
 using namespace boost::asio::experimental::awaitable_operators;
 
-net::awaitable<void> test_reconnect_impl(std::shared_ptr<connection> db)
+net::awaitable<void> test_reconnect_impl()
 {
-   request req;
+   auto ex = co_await net::this_coro::executor;
+
+   resp3::request req;
    req.push("QUIT");
 
+   auto const endpoints = resolve();
+   connection conn{ex};
+
    int i = 0;
-   endpoint ep{"127.0.0.1", "6379"};
    for (; i < 5; ++i) {
       boost::system::error_code ec1, ec2;
+      net::connect(conn.next_layer(), endpoints);
       co_await (
-         db->async_exec(req, adapt(), net::redirect_error(net::use_awaitable, ec1)) &&
-         db->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec2))
+         conn.async_exec(req, adapt(), net::redirect_error(net::use_awaitable, ec1)) &&
+         conn.async_run(net::redirect_error(net::use_awaitable, ec2))
       );
 
       BOOST_TEST(!ec1);
       BOOST_TEST(!ec2);
-      db->reset_stream();
+      conn.reset_stream();
    }
 
    BOOST_CHECK_EQUAL(i, 5);
@@ -51,51 +56,62 @@ net::awaitable<void> test_reconnect_impl(std::shared_ptr<connection> db)
 // Test whether the client works after a reconnect.
 BOOST_AUTO_TEST_CASE(test_reconnect)
 {
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
    net::io_context ioc;
-   auto db = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, test_reconnect_impl(db), net::detached);
+   net::co_spawn(ioc, test_reconnect_impl(), net::detached);
    ioc.run();
 }
 
 auto async_test_reconnect_timeout() -> net::awaitable<void>
 {
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   endpoint ep{"127.0.0.1", "6379"};
-   boost::system::error_code ec1, ec2;
+   auto ex = co_await net::this_coro::executor;
 
-   request req1;
+   net::steady_timer st{ex};
+
+   auto conn = std::make_shared<connection>(ex);
+   boost::system::error_code ec1, ec2, ec3;
+
+   resp3::request req1;
    req1.get_config().cancel_if_not_connected = false;
    req1.get_config().cancel_on_connection_lost = true;
-   req1.push("CLIENT", "PAUSE", 7000);
+   req1.get_config().cancel_if_unresponded = true;
+   req1.push("HELLO", 3);
+   req1.push("BLPOP", "any", 0);
 
+   co_await connect(conn, "127.0.0.1", "6379");
+   st.expires_after(std::chrono::seconds{1});
    co_await (
-      conn->async_exec(req1, adapt(), net::redirect_error(net::use_awaitable, ec1)) &&
-      conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec2))
+      conn->async_exec(req1, adapt(), redir(ec1)) ||
+      conn->async_run(redir(ec2)) ||
+      st.async_wait(redir(ec3))
    );
 
-   BOOST_TEST(!ec1);
-   BOOST_CHECK_EQUAL(ec2, aedis::error::idle_timeout);
+   //BOOST_TEST(!ec1);
+   BOOST_CHECK_EQUAL(ec2, boost::system::errc::errc_t::operation_canceled);
+   //BOOST_TEST(!ec3);
 
-   request req2;
+   resp3::request req2;
    req2.get_config().cancel_if_not_connected = false;
    req2.get_config().cancel_on_connection_lost = true;
+   req2.get_config().cancel_if_unresponded= true;
+   req2.push("HELLO", 3);
    req2.push("QUIT");
 
+   co_await connect(conn, "127.0.0.1", "6379");
+   st.expires_after(std::chrono::seconds{1});
    co_await (
-      conn->async_exec(req1, adapt(), net::redirect_error(net::use_awaitable, ec1)) &&
-      conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec2))
+      conn->async_exec(req1, adapt(), net::redirect_error(net::use_awaitable, ec1)) ||
+      conn->async_run(net::redirect_error(net::use_awaitable, ec2)) ||
+      st.async_wait(net::redirect_error(net::use_awaitable, ec3))
    );
+   std::cout << "ccc" << std::endl;
 
    BOOST_CHECK_EQUAL(ec1, boost::system::errc::errc_t::operation_canceled);
-   BOOST_CHECK_EQUAL(ec2, aedis::error::exec_timeout);
+   BOOST_CHECK_EQUAL(ec2, boost::asio::error::basic_errors::operation_aborted);
 }
 
 BOOST_AUTO_TEST_CASE(test_reconnect_and_idle)
 {
-   net::io_context ioc;
-   net::co_spawn(ioc, async_test_reconnect_timeout(), net::detached);
-   ioc.run();
+   run(async_test_reconnect_timeout());
 }
 #else
 int main(){}

tests/conn_run_cancel.cpp

@@ -15,14 +15,14 @@
 
 #include <aedis.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
 
 namespace net = boost::asio;
 
 using aedis::resp3::request;
 using aedis::operation;
 using aedis::adapt;
-using connection = aedis::connection<>;
-using endpoint = aedis::endpoint;
+using connection = aedis::connection;
 using error_code = boost::system::error_code;
 using net::experimental::as_tuple;
 
@@ -32,16 +32,15 @@ using namespace net::experimental::awaitable_operators;
 auto async_cancel_run_with_timer() -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
+   auto const endpoints = resolve();
+   connection conn{ex};
+   net::connect(conn.next_layer(), endpoints);
+
    net::steady_timer st{ex};
    st.expires_after(std::chrono::seconds{1});
 
-   endpoint ep{"127.0.0.1", "6379"};
    boost::system::error_code ec1, ec2;
-   co_await (
-      conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) ||
-      st.async_wait(net::redirect_error(net::use_awaitable, ec2))
-   );
+   co_await (conn.async_run(redir(ec1)) || st.async_wait(redir(ec2)));
 
    BOOST_CHECK_EQUAL(ec1, boost::asio::error::basic_errors::operation_aborted);
    BOOST_TEST(!ec2);
@@ -54,29 +53,20 @@ BOOST_AUTO_TEST_CASE(cancel_run_with_timer)
    ioc.run();
 }
 
-net::awaitable<void>
-async_check_cancellation_not_missed(
-   std::shared_ptr<connection> conn,
-   int n,
-   std::chrono::milliseconds ms)
+auto
+async_check_cancellation_not_missed(int n, std::chrono::milliseconds ms) -> net::awaitable<void>
 {
-   net::steady_timer timer{co_await net::this_coro::executor};
+   auto ex = co_await net::this_coro::executor;
+   auto const endpoints = resolve();
+   connection conn{ex};
 
-   connection::timeouts tms;
-   tms.resolve_timeout = std::chrono::seconds{10};
-   tms.connect_timeout = std::chrono::seconds{10};
-   tms.resp3_handshake_timeout = std::chrono::seconds{2};
-   tms.ping_interval = std::chrono::seconds{1};
-
-   endpoint ep{"127.0.0.1", "6379"};
+   net::steady_timer timer{ex};
 
    for (auto i = 0; i < n; ++i) {
       timer.expires_after(ms);
+      net::connect(conn.next_layer(), endpoints);
       boost::system::error_code ec1, ec2;
-      co_await (
-         conn->async_run(ep, {}, net::redirect_error(net::use_awaitable, ec1)) ||
-         timer.async_wait(net::redirect_error(net::use_awaitable, ec2))
-      );
+      co_await (conn.async_run(redir(ec1)) || timer.async_wait(redir(ec2)));
       BOOST_CHECK_EQUAL(ec1, boost::asio::error::basic_errors::operation_aborted);
       std::cout << "Counter: " << i << std::endl;
    }
@@ -86,104 +76,123 @@ async_check_cancellation_not_missed(
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_0)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 10, std::chrono::milliseconds{0}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(10, std::chrono::milliseconds{0}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_2)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{2}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{2}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_8)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{8}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{8}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_16)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{16}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{16}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_32)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{32}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{32}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_64)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{64}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{64}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_128)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{128}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{128}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_256)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{256}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{256}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_512)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{512}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{512}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(check_implicit_cancel_not_missed_1024)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-   net::co_spawn(ioc, async_check_cancellation_not_missed(conn, 20, std::chrono::milliseconds{1024}), net::detached);
+   net::co_spawn(ioc, async_check_cancellation_not_missed(20, std::chrono::milliseconds{1024}), net::detached);
    ioc.run();
 }
 
 BOOST_AUTO_TEST_CASE(reset_before_run_completes)
 {
    net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
+   auto const endpoints = resolve();
+   connection conn{ioc};
+   net::connect(conn.next_layer(), endpoints);
+
 
    // Sends a ping just as a means of waiting until we are connected.
    request req;
+   req.push("HELLO", 3);
    req.push("PING");
 
-   conn->async_exec(req, adapt(), [conn](auto ec, auto){
+   conn.async_exec(req, adapt(), [&](auto ec, auto){
       BOOST_TEST(!ec);
-      conn->reset_stream();
+      conn.reset_stream();
    });
 
-   conn->async_run({"127.0.0.1", "6379"}, {}, [conn](auto ec){
+   conn.async_run([&](auto ec){
       BOOST_CHECK_EQUAL(ec, net::error::operation_aborted);
    });
 
    ioc.run();
 }
 
+using slave_operation = aedis::detail::guarded_operation<net::any_io_executor>;
+
+auto master(std::shared_ptr<slave_operation> op) -> net::awaitable<void>
+{
+   co_await op->async_run(net::use_awaitable);
+}
+
+auto slave(std::shared_ptr<slave_operation> op) -> net::awaitable<void>
+{
+   net::steady_timer timer{co_await net::this_coro::executor};
+   timer.expires_after(std::chrono::seconds{1});
+
+   co_await op->async_wait(timer.async_wait(net::deferred), net::use_awaitable);
+   std::cout << "Kabuf" << std::endl;
+}
+
+BOOST_AUTO_TEST_CASE(slave_op)
+{
+   net::io_context ioc;
+   auto op = std::make_shared<slave_operation>(ioc.get_executor());
+   net::co_spawn(ioc, master(op), net::detached);
+   net::co_spawn(ioc, slave(op), net::detached);
+   ioc.run();
+}
+
 #else
 int main(){}
 #endif

tests/conn_tls.cpp

@@ -14,12 +14,18 @@
 #include <aedis.hpp>
 #include <aedis/ssl/connection.hpp>
 #include <aedis/src.hpp>
+#include "common.hpp"
 
 namespace net = boost::asio;
 
 using aedis::adapt;
-using connection = aedis::ssl::connection<net::ssl::stream<net::ip::tcp::socket>>;
-using endpoint = aedis::endpoint;
+using aedis::resp3::request;
+using connection = aedis::ssl::connection;
+
+struct endpoint {
+   std::string host;
+   std::string port;
+};
 
 bool verify_certificate(bool, net::ssl::verify_context&)
 {
@@ -27,54 +33,40 @@ bool verify_certificate(bool, net::ssl::verify_context&)
    return true;
 }
 
-boost::system::error_code hello_fail(endpoint ep)
+BOOST_AUTO_TEST_CASE(ping)
 {
-   net::io_context ioc;
+   std::string const in = "Kabuf";
 
+   request req;
+   req.get_config().cancel_on_connection_lost = true;
+   req.push("HELLO", 3, "AUTH", "aedis", "aedis");
+   req.push("PING", in);
+   req.push("QUIT");
+
+   std::string out;
+   auto resp = std::tie(std::ignore, out, std::ignore);
+
+   auto const endpoints = resolve("db.occase.de", "6380");
+
+   net::io_context ioc;
    net::ssl::context ctx{net::ssl::context::sslv23};
-   auto conn = std::make_shared<connection>(ioc.get_executor(), ctx);
-   conn->next_layer().set_verify_mode(net::ssl::verify_peer);
-   conn->next_layer().set_verify_callback(verify_certificate);
-   boost::system::error_code ret;
-   conn->async_run(ep, {}, [&](auto ec) {
-      ret = ec;
+   connection conn{ioc, ctx};
+   conn.next_layer().set_verify_mode(net::ssl::verify_peer);
+   conn.next_layer().set_verify_callback(verify_certificate);
+
+   net::connect(conn.lowest_layer(), endpoints);
+   conn.next_layer().handshake(net::ssl::stream_base::client);
+
+   conn.async_exec(req, adapt(resp), [](auto ec, auto) {
+      BOOST_TEST(!ec);
+   });
+
+   conn.async_run([](auto ec) {
+      BOOST_TEST(!ec);
    });
 
    ioc.run();
-   return ret;
-}
-
-BOOST_AUTO_TEST_CASE(test_tls_handshake_fail)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "google.com";
-   ep.port = "80";
-   auto const ec = hello_fail(ep);
-   BOOST_TEST(!!ec);
-   std::cout << "-----> " << ec.message() << std::endl;
-}
-
-BOOST_AUTO_TEST_CASE(test_tls_handshake_fail2)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "127.0.0.1";
-   ep.port = "6379";
-   auto const ec = hello_fail(ep);
-   BOOST_CHECK_EQUAL(ec, aedis::error::ssl_handshake_timeout);
-}
-
-BOOST_AUTO_TEST_CASE(test_hello_fail)
-{
-   std::cout << boost::unit_test::framework::current_test_case().p_name << std::endl;
-
-   endpoint ep;
-   ep.host = "google.com";
-   ep.port = "443";
-   auto const ec = hello_fail(ep);
-   BOOST_CHECK_EQUAL(ec, aedis::error::invalid_data_type);
+
+   BOOST_CHECK_EQUAL(in, out);
 }
 

tests/request.cpp

@@ -10,7 +10,7 @@
 #define BOOST_TEST_MODULE low level
 #include <boost/test/included/unit_test.hpp>
 
-#include <aedis.hpp>
+#include <aedis/resp3/request.hpp>
 #include <aedis/src.hpp>
 
 using aedis::resp3::request;