Merge pull request #235 from boostorg/develop

Develop to master

.codecov.yml

@@ -7,7 +7,7 @@ codecov:
 
 ignore:
   - "benchmarks/cpp/asio/*"
-  - "examples/*"
+  - "example/*"
   - "tests/*"
   - "/usr/*"
   - "**/boost/*"

.github/workflows/ci.yml

@@ -1,10 +1,18 @@
+# CI script to verify that CMake and B2 builds work.
+# B2 builds include only tests that don't require a DB server, to avoid race conditions.
+# CMake tests include the actual project tests and all the CMake integration workflows
+#   recommended by Boost.CI.
+# Windows CMake jobs build the code but don't run the tests,
+#   since we don't have a way to set up a Redis server on Windows (yet).
+# Subcommands are implemented by the tools/ci.py script in a platform-independent manner.
+
 name: CI
 
 on: [push, pull_request]
 
 jobs:
-  windows:
-    name: "${{matrix.generator}} ${{matrix.toolset}} Boost ${{matrix.boost_version}} ${{matrix.build_type}} ${{matrix.name_args}}"
+  windows-cmake:
+    name: "CMake ${{matrix.toolset}} ${{matrix.build-type}} C++${{matrix.cxxstd}}"
     runs-on: ${{matrix.os}}
     defaults:
       run:
@@ -12,84 +20,109 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        boost_version: ["1.81.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.81.0", toolset: v143 }
-
+        include:
+          - { toolset: msvc-14.2, os: windows-2019, generator: "Visual Studio 16 2019", cxxstd: '17', build-type: 'Debug',   build-shared-libs: 1 }
+          - { toolset: msvc-14.2, os: windows-2019, generator: "Visual Studio 16 2019", cxxstd: '17', build-type: 'Release', build-shared-libs: 0 }
+          - { toolset: msvc-14.3, os: windows-2022, generator: "Visual Studio 17 2022", cxxstd: '20', build-type: 'Debug',   build-shared-libs: 0 }
+          - { toolset: msvc-14.3, os: windows-2022, generator: "Visual Studio 17 2022", cxxstd: '20', build-type: 'Release', build-shared-libs: 1 }
+    env:
+      CMAKE_BUILD_PARALLEL_LEVEL: 4
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
-      with:
-        fetch-depth: 0
+      uses: actions/checkout@v4
 
-    - name: Add boost toolset to environment
-      if: contains(fromJson('["1.81.0"]'), matrix.boost_version)
-      run: echo BOOST_TOOLSET=$(echo "msvc") >> $GITHUB_ENV
+    - name: Setup Boost
+      run: python3 tools/ci.py setup-boost --source-dir=$(pwd)
 
-    # 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
+    - name: Build a Boost distribution using B2
       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
+        python3 tools/ci.py build-b2-distro \
+          --toolset ${{ matrix.toolset }}
 
-    - 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 openssl
-      run: choco install openssl
-
-    - name: Create build directory
-      run: mkdir build
-
-    - name: Configure
-      working-directory: build
+    - name: Build a Boost distribution using CMake
       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
+        python3 tools/ci.py build-cmake-distro \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }} \
+          --generator "${{ matrix.generator }}" \
+          --build-shared-libs ${{ matrix.build-shared-libs }}
+        
+    - name: Build the project tests
       run: |
-        cmake --build . ${BUILD_CONFIG_ARG} ${{matrix.build_args}}
+        python3 tools/ci.py build-cmake-standalone-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }} \
+          --generator "${{ matrix.generator }}" \
+          --build-shared-libs ${{ matrix.build-shared-libs }}
 
-  posix:
+    # # TODO: re-enable this when a Redis server is available for this job
+    # - name: Run the project tests
+    #   run: |
+    #     python3 tools/ci.py run-cmake-standalone-tests \
+    #       --build-type ${{ matrix.build-type }}
+
+    - name: Run add_subdirectory tests
+      run: |
+        python3 tools/ci.py run-cmake-add-subdirectory-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }} \
+          --generator "${{ matrix.generator }}" \
+          --build-shared-libs ${{ matrix.build-shared-libs }}
+
+    - name: Run find_package tests with the built cmake distribution
+      run: |
+        python3 tools/ci.py run-cmake-find-package-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }} \
+          --generator "${{ matrix.generator }}" \
+          --build-shared-libs ${{ matrix.build-shared-libs }}
+
+    - name: Run find_package tests with the built b2 distribution
+      run: |
+        python3 tools/ci.py run-cmake-b2-find-package-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }} \
+          --generator "${{ matrix.generator }}" \
+          --build-shared-libs ${{ matrix.build-shared-libs }}
+
+  windows-b2:
+    name: "B2 ${{matrix.toolset}}"
+    runs-on: ${{matrix.os}}
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { toolset: msvc-14.2, os: windows-2019 }
+          - { toolset: msvc-14.3, os: windows-2022 }
+    env:
+      OPENSSL_ROOT: "C:\\Program Files\\OpenSSL"
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Setup user-config.jam
+      run: cp tools/user-config.jam "${HOMEDRIVE}${HOMEPATH}/"
+
+    - name: Setup Boost
+      run: python3 tools/ci.py setup-boost --source-dir=$(pwd)
+    
+    - name: Build and run project tests using B2
+      run: |
+        python3 tools/ci.py run-b2-tests \
+          --toolset ${{ matrix.toolset }} \
+          --cxxstd 17,20 \
+          --variant debug,release
+
+  posix-cmake:
+    name: "CMake ${{ matrix.toolset }} ${{ matrix.cxxstd }} ${{ matrix.build-type }} ${{ matrix.cxxflags }}"
     defaults:
       run:
         shell: bash
@@ -98,39 +131,183 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
-          - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
-          - { toolset: clang, compiler: clang++-11, install: clang-11, os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
-          - { toolset: clang, compiler: clang++-11, install: clang-11, os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
-          - { toolset: clang, compiler: clang++-13, install: clang-13, os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
-          - { toolset: clang, compiler: clang++-13, install: clang-13, os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
-          - { toolset: clang, compiler: clang++-14, install: 'clang-14 libc++-14-dev libc++abi-14-dev', os: ubuntu-22.04, cxxflags: '-std=c++17 -stdlib=libc++', ldflags: '-lc++' }
-          - { toolset: clang, compiler: clang++-14, install: 'clang-14 libc++-14-dev libc++abi-14-dev', os: ubuntu-22.04, cxxflags: '-std=c++20 -stdlib=libc++', ldflags: '-lc++' }
+          - toolset: gcc-11
+            install: g++-11
+            os: ubuntu-latest
+            cxxstd: '17'
+            build-type: 'Debug'
+            ldflags: ''
+
+          - toolset: gcc-11
+            install: g++-11
+            os: ubuntu-latest
+            cxxstd: '20'
+            build-type: 'Release'
+            ldflags: ''
+
+          - toolset: clang-11
+            install: clang-11
+            os: ubuntu-latest
+            cxxstd: '17'
+            build-type: 'Debug'
+            ldflags: ''
+
+          - toolset: clang-11
+            install: clang-11
+            os: ubuntu-latest
+            cxxstd: '20'
+            build-type: 'Debug'
+            ldflags: ''
+
+          - toolset: clang-13
+            install: clang-13
+            os: ubuntu-latest
+            cxxstd: '17'
+            build-type: 'Release'
+            ldflags: ''
+
+          - toolset: clang-13
+            install: clang-13
+            os: ubuntu-latest
+            cxxstd: '20'
+            build-type: 'Release'
+            ldflags: ''
+
+          - toolset: clang-14
+            install: 'clang-14 libc++-14-dev libc++abi-14-dev'
+            os: ubuntu-latest
+            cxxstd: '17'
+            build-type: 'Debug'
+            cxxflags: '-stdlib=libc++'
+            ldflags: '-lc++'
+
+          - toolset: clang-14
+            install: 'clang-14 libc++-14-dev libc++abi-14-dev'
+            os: ubuntu-latest
+            cxxstd: '20'
+            build-type: 'Release'
+            cxxflags: '-stdlib=libc++'
+            ldflags: '-lc++'
+
     runs-on: ${{ matrix.os }}
     env:
-      CXXFLAGS: -g -O0 ${{matrix.cxxflags}} -Wall -Wextra
+      CXXFLAGS: ${{matrix.cxxflags}} -Wall -Wextra
       LDFLAGS:  ${{matrix.ldflags}}
+      CMAKE_BUILD_PARALLEL_LEVEL: 4
+    
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
-    - name: Install CMake
-      run: sudo apt-get -y install cmake
-    - name: Install protobuf
-      run: sudo apt-get -y install protobuf-compiler
-    - name: Install compiler
-      run: sudo apt-get install -y ${{ matrix.install }}
-    - name: Install Redis
-      run: sudo apt-get install -y redis-server
-    - name: Install boost
-      uses: MarkusJx/install-boost@v2.4.1
-      id: install-boost
-      with:
-        boost_version: 1.81.0
-        platform_version: 22.04
-    - name: Run CMake
+      uses: actions/checkout@v4
+    
+    - name: Set up the required containers
       run: |
-        BOOST_ROOT=${{steps.install-boost.outputs.BOOST_ROOT}} cmake -DCMAKE_CXX_COMPILER="${{matrix.compiler}}" -DCMAKE_CXX_FLAGS="${{env.CXXFLAGS}}"  -DCMAKE_EXE_LINKER_FLAGS="${{env.LDFLAGS}}"
-    - name: Build
-      run: make
-    - name: Check
-      run: ctest --output-on-failure
+        docker compose -f tools/docker-compose.yml up -d --wait || (docker compose logs; exit 1)
+      
+    - name: Install dependencies
+      run: |
+        docker exec builder apt-get update
+        docker exec builder apt-get -y --no-install-recommends install \
+          git \
+          g++ \
+          libssl-dev \
+          make \
+          ca-certificates \
+          cmake \
+          protobuf-compiler \
+          python3 \
+          ${{ matrix.install }}
+
+    - name: Setup Boost
+      run: docker exec builder /boost-redis/tools/ci.py setup-boost --source-dir=/boost-redis
+
+    - name: Build a Boost distribution using B2
+      run: |
+        docker exec builder /boost-redis/tools/ci.py build-b2-distro \
+          --toolset ${{ matrix.toolset }}
+
+    - name: Build a Boost distribution using CMake
+      run: |
+        docker exec builder /boost-redis/tools/ci.py build-cmake-distro \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }}
+
+    - name: Build the project tests
+      run: |
+        docker exec builder /boost-redis/tools/ci.py build-cmake-standalone-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }}
+  
+    - name: Run the project tests
+      run: |
+        docker exec builder /boost-redis/tools/ci.py run-cmake-standalone-tests \
+          --build-type ${{ matrix.build-type }}
+
+    - name: Run add_subdirectory tests
+      run: |
+        docker exec builder /boost-redis/tools/ci.py run-cmake-add-subdirectory-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }}
+
+    - name: Run find_package tests with the built cmake distribution
+      run: |
+        docker exec builder /boost-redis/tools/ci.py run-cmake-find-package-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }}
+
+    - name: Run find_package tests with the built b2 distribution
+      run: |
+        docker exec builder /boost-redis/tools/ci.py run-cmake-b2-find-package-tests \
+          --build-type ${{ matrix.build-type }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --toolset ${{ matrix.toolset }}
+
+  posix-b2:
+    name: "B2 ${{ matrix.toolset }}"
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-11
+            install: g++-11
+            cxxstd: "11,17,20" # Having C++11 shouldn't break the build
+            os: ubuntu-latest
+            container: ubuntu:22.04
+          - toolset: clang-14
+            install: clang-14
+            os: ubuntu-latest
+            container: ubuntu:22.04
+            cxxstd: "17,20"
+    runs-on: ${{ matrix.os }}
+    container: ${{matrix.container}}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Setup container environment
+      if: matrix.container
+      run: |
+        apt-get update
+        apt-get -y install sudo python3 git g++ libssl-dev
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install python3 ${{ matrix.install }}
+
+    - name: Setup Boost
+      run: ./tools/ci.py setup-boost --source-dir=$(pwd)
+    
+    - name: Build and run project tests using B2
+      run: |
+        python3 tools/ci.py run-b2-tests \
+          --toolset ${{ matrix.toolset }} \
+          --cxxstd ${{ matrix.cxxstd }} \
+          --variant debug,release

.github/workflows/coverage.yml

@@ -1,47 +0,0 @@
-name: Coverage
-
-on:
-  push:
-    branches:
-      - develop
-jobs:
-  posix:
-    defaults:
-      run:
-        shell: bash
-
-    runs-on: ubuntu-22.04
-    env:
-      CXX: g++-11
-      CXXFLAGS: -g -O0 -std=c++20 --coverage -fkeep-inline-functions -fkeep-static-functions
-      LDFLAGS: --coverage
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Install CMake
-      run: sudo apt-get -y install cmake
-    - name: Install lcov
-      run: sudo apt-get -y install lcov
-    - name: Install compiler
-      run: sudo apt-get -y install g++-11
-    - name: Install Redis
-      run: sudo apt-get -y install redis-server
-    - name: Install boost
-      uses: MarkusJx/install-boost@v2.4.1
-      id: install-boost
-      with:
-        boost_version: 1.81.0
-        platform_version: 22.04
-    - name: Run CMake
-      run: |
-        BOOST_ROOT=${{steps.install-boost.outputs.BOOST_ROOT}} cmake --preset coverage .
-    - name: Build
-      run: cmake --build --preset coverage
-    - name: Test
-      run: ctest --preset coverage
-    - name: Make the coverage file
-      run: cmake --build --preset coverage --target coverage
-    - name: Upload to codecov
-      run: |
-        bash <(curl -s https://codecov.io/bash) -f ./build/coverage/coverage.info || echo "Codecov did not collect coverage reports"
-

CMakeLists.txt

@@ -1,264 +1,141 @@
-cmake_minimum_required(VERSION 3.14)
-
-#set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time")
+cmake_minimum_required(VERSION 3.8...3.20)
 
 # determine whether it's main/root project
 # or being built under another project.
 if (NOT DEFINED BOOST_REDIS_MAIN_PROJECT)
-   set(BOOST_REDIS_MAIN_PROJECT OFF)
-   if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-      set(BOOST_REDIS_MAIN_PROJECT ON)
-   endif()
+  set(BOOST_REDIS_MAIN_PROJECT OFF)
+  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(BOOST_REDIS_MAIN_PROJECT ON)
+  endif()
 endif()
 
-project(
-    boost_redis
-    VERSION 1.4.1
-    DESCRIPTION "A redis client library"
-    HOMEPAGE_URL "https://boostorg.github.io/redis/"
-    LANGUAGES CXX
-)
-
-option(BOOST_REDIS_INSTALL "Generate install targets." ${BOOST_REDIS_MAIN_PROJECT})
-option(BOOST_REDIS_TESTS "Build tests." ${BOOST_REDIS_MAIN_PROJECT})
-option(BOOST_REDIS_EXAMPLES "Build examples." ${BOOST_REDIS_MAIN_PROJECT})
-option(BOOST_REDIS_BENCHMARKS "Build benchmarks." ${BOOST_REDIS_MAIN_PROJECT})
-option(BOOST_REDIS_DOC "Generate documentations." ${BOOST_REDIS_MAIN_PROJECT})
+project(boost_redis VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
+# Library
 add_library(boost_redis INTERFACE)
 add_library(Boost::redis ALIAS boost_redis)
-target_include_directories(boost_redis INTERFACE
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include>
-)
-
-target_link_libraries(
-  boost_redis
-  INTERFACE
-    Boost::asio
-    Boost::assert
-    Boost::config
-    Boost::core
-    Boost::mp11
-    Boost::system
-    Boost::utility
-)
-
+target_include_directories(boost_redis INTERFACE include)
 target_compile_features(boost_redis INTERFACE cxx_std_17)
 
-# Asio bases C++ feature detection on __cplusplus. Make MSVC
-# define it correctly
-if (MSVC)
-  target_compile_options(boost_redis INTERFACE /Zc:__cplusplus)
-endif()
+# Dependencies
+if (BOOST_REDIS_MAIN_PROJECT)
+  # TODO: Understand why we have to list all dependencies below
+  # instead of
+  #set(BOOST_INCLUDE_LIBRARIES redis)
+  #set(BOOST_EXCLUDE_LIBRARIES redis)
+  #add_subdirectory(../.. boostorg/boost EXCLUDE_FROM_ALL)
 
-find_package(Boost 1.80 REQUIRED)
+  set(deps
+    system
+    assert
+    config
+    throw_exception
+    asio
+    variant2
+    mp11
+    winapi
+    predef
+    align
+    context
+    core
+    static_assert
+    pool
+    date_time
+    smart_ptr
+    exception
+    integer
+    move
+    type_traits
+    algorithm
+    utility
+    io
+    lexical_cast
+    numeric/conversion
+    mpl
+    range
+    tokenizer
+    tuple
+    array
+    bind
+    concept_check
+    function
+    iterator
+    regex
+    unordered
+    preprocessor
+    container
+    conversion
+    container_hash
+    detail
+    optional
+    function_types
+    fusion
+    intrusive
+    describe
+    typeof
+    functional
+    test
+    json
+    endian
+  )
 
-include_directories(${Boost_INCLUDE_DIRS})
+  foreach(dep IN LISTS deps)
+    add_subdirectory(../${dep} boostorg/${dep})
+  endforeach()
 
-find_package(OpenSSL REQUIRED)
-
-include_directories(include)
-
-# Common
-#=======================================================================
-
-add_library(boost_redis_project_options INTERFACE)
-target_link_libraries(boost_redis_project_options INTERFACE OpenSSL::Crypto OpenSSL::SSL)
-if (MSVC)
-   target_compile_options(boost_redis_project_options INTERFACE /bigobj)
-   target_compile_definitions(boost_redis_project_options INTERFACE _WIN32_WINNT=0x0601)
-endif()
-
-add_library(boost_redis_src STATIC examples/boost_redis.cpp)
-target_compile_features(boost_redis_src PRIVATE cxx_std_17)
-target_link_libraries(boost_redis_src PRIVATE boost_redis_project_options)
-
-# Executables
-#=======================================================================
-
-if (BOOST_REDIS_BENCHMARKS)
-  add_library(benchmarks_options INTERFACE)
-  target_link_libraries(benchmarks_options INTERFACE boost_redis_src)
-  target_link_libraries(benchmarks_options INTERFACE boost_redis_project_options)
-  target_compile_features(benchmarks_options INTERFACE cxx_std_20)
-
-  add_executable(echo_server_client benchmarks/cpp/asio/echo_server_client.cpp)
-  target_link_libraries(echo_server_client PRIVATE benchmarks_options)
-
-  add_executable(echo_server_direct benchmarks/cpp/asio/echo_server_direct.cpp)
-  target_link_libraries(echo_server_direct PRIVATE benchmarks_options)
-endif()
-
-if (BOOST_REDIS_EXAMPLES)
-  add_library(examples_main STATIC examples/main.cpp)
-  target_compile_features(examples_main PRIVATE cxx_std_20)
-  target_link_libraries(examples_main PRIVATE boost_redis_project_options)
-
-  macro(make_example EXAMPLE_NAME STANDARD)
-    add_executable(${EXAMPLE_NAME} examples/${EXAMPLE_NAME}.cpp)
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_src)
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_project_options)
-    target_compile_features(${EXAMPLE_NAME} PRIVATE cxx_std_${STANDARD})
-    if (${STANDARD} STREQUAL "20")
-      target_link_libraries(${EXAMPLE_NAME} PRIVATE examples_main)
-    endif()
-  endmacro()
-
-  macro(make_testable_example EXAMPLE_NAME STANDARD)
-    make_example(${EXAMPLE_NAME} ${STANDARD})
-    add_test(${EXAMPLE_NAME} ${EXAMPLE_NAME})
-  endmacro()
-
-  make_testable_example(cpp17_intro 17)
-  make_testable_example(cpp17_intro_sync 17)
-
-  make_testable_example(cpp20_intro 20)
-  make_testable_example(cpp20_containers 20)
-  make_testable_example(cpp20_json 20)
-  make_testable_example(cpp20_intro_tls 20)
-
-  make_example(cpp20_subscriber 20)
-  make_example(cpp20_streams 20)
-  make_example(cpp20_echo_server 20)
-  make_example(cpp20_resolve_with_sentinel 20)
-
-  # We test the protobuf example only on gcc.
-  if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    find_package(Protobuf)
-    if (Protobuf_FOUND)
-       protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS examples/person.proto)
-       make_testable_example(cpp20_protobuf 20)
-       target_sources(cpp20_protobuf PUBLIC ${PROTO_SRCS} ${PROTO_HDRS})
-       target_link_libraries(cpp20_protobuf PRIVATE  ${Protobuf_LIBRARIES})
-       target_include_directories(cpp20_protobuf PUBLIC ${Protobuf_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
-    endif()
+  find_package(Threads REQUIRED)
+  find_package(OpenSSL REQUIRED)
+  target_link_libraries(boost_redis
+    INTERFACE
+      Boost::system
+      Boost::asio
+      Threads::Threads
+      OpenSSL::Crypto
+      OpenSSL::SSL
+  )
+else()
+  # If we're in the superproject or called from add_subdirectory,
+  # Boost dependencies should be already available.
+  # If other dependencies are not found, we bail out
+  find_package(Threads)
+  if(NOT Threads_FOUND)
+    message(STATUS "Boost.Redis has been disabled, because the required package Threads hasn't been found")
+    return()
+  endif()
+  find_package(OpenSSL)
+  if(NOT OpenSSL_FOUND)
+    message(STATUS "Boost.Redis has been disabled, because the required package OpenSSL hasn't been found")
+    return()
   endif()
 
-  if (NOT MSVC)
-     make_example(cpp20_chat_room 20)
-  endif()
-endif()
-
-if (BOOST_REDIS_TESTS)
-  enable_testing()
-
-  add_library(tests_common STATIC tests/common.cpp)
-  target_compile_features(tests_common PRIVATE cxx_std_17)
-  target_link_libraries(tests_common PRIVATE boost_redis_project_options)
-
-  macro(make_test TEST_NAME STANDARD)
-    add_executable(${TEST_NAME} tests/${TEST_NAME}.cpp)
-    target_link_libraries(${TEST_NAME} PRIVATE boost_redis_src tests_common)
-    target_link_libraries(${TEST_NAME} PRIVATE boost_redis_project_options)
-    target_compile_features(${TEST_NAME} PRIVATE cxx_std_${STANDARD})
-    add_test(${TEST_NAME} ${TEST_NAME})
-  endmacro()
-
-  make_test(test_conn_quit 17)
-  make_test(test_conn_tls 17)
-  make_test(test_low_level 17)
-  make_test(test_conn_exec_retry 17)
-  make_test(test_conn_exec_error 17)
-  make_test(test_request 17)
-  make_test(test_run 17)
-  make_test(test_low_level_sync 17)
-  make_test(test_low_level_sync_sans_io 17)
-  make_test(test_conn_check_health 17)
-
-  make_test(test_conn_exec 20)
-  make_test(test_conn_push 20)
-  make_test(test_conn_reconnect 20)
-  make_test(test_conn_exec_cancel 20)
-  make_test(test_conn_exec_cancel2 20)
-  make_test(test_conn_echo_stress 20)
-  make_test(test_low_level_async 20)
-  make_test(test_conn_run_cancel 20)
-  make_test(test_issue_50 20)
-endif()
-
-# Install
-#=======================================================================
-
-if (BOOST_REDIS_INSTALL)
-  install(TARGETS boost_redis
-      EXPORT boost_redis
-      PUBLIC_HEADER DESTINATION include COMPONENT Development
-  )
-  
-  include(CMakePackageConfigHelpers)
-  
-  configure_package_config_file(
-     "${PROJECT_SOURCE_DIR}/cmake/BoostRedisConfig.cmake.in"
-     "${PROJECT_BINARY_DIR}/BoostRedisConfig.cmake"
-      INSTALL_DESTINATION lib/cmake/boost/redis
-  )
-  
-  install(EXPORT boost_redis DESTINATION lib/cmake/boost/redis)
-  install(FILES "${PROJECT_BINARY_DIR}/BoostRedisConfigVersion.cmake"
-     "${PROJECT_BINARY_DIR}/BoostRedisConfig.cmake"
-       DESTINATION lib/cmake/boost/redis)
-  
-  install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/ DESTINATION include)
-
-  include(CMakePackageConfigHelpers)
-  write_basic_package_version_file(
-    "${PROJECT_BINARY_DIR}/BoostRedisConfigVersion.cmake"
-    COMPATIBILITY AnyNewerVersion
-  )
-
-  include(CPack)
-endif()
-
-# Doxygen
-#=======================================================================
-
-if (BOOST_REDIS_DOC)
-  set(DOXYGEN_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/doc")
-  configure_file(doc/Doxyfile.in doc/Doxyfile @ONLY)
-  
-  add_custom_target(
-      doc
-      COMMAND doxygen "${PROJECT_BINARY_DIR}/doc/Doxyfile"
-      COMMENT "Building documentation using Doxygen"
-      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
-      VERBATIM
+  # This is generated by boostdep
+  target_link_libraries(boost_redis
+    INTERFACE
+      Boost::asio
+      Boost::assert
+      Boost::core
+      Boost::mp11
+      Boost::system
+      Boost::throw_exception
+      Threads::Threads
+      OpenSSL::Crypto
+      OpenSSL::SSL
   )
 endif()
 
-# Coverage
-#=======================================================================
+# Enable testing. If we're being called from the superproject, this has already been done
+if (BOOST_REDIS_MAIN_PROJECT)
+  include(CTest)
+endif()
 
-set(
-    COVERAGE_TRACE_COMMAND
-    lcov --capture
-    -output-file "${PROJECT_BINARY_DIR}/coverage.info"
-    --directory "${PROJECT_BINARY_DIR}"
-    --include "${PROJECT_SOURCE_DIR}/include/*"
-)
+# Most tests require a running Redis server, so we only run them if we're the main project
+if(BOOST_REDIS_MAIN_PROJECT AND BUILD_TESTING)
+  # Tests and common utilities
+  add_subdirectory(test)
 
-set(
-    COVERAGE_HTML_COMMAND
-    genhtml --legend -f -q
-    "${PROJECT_BINARY_DIR}/coverage.info"
-    --prefix "${PROJECT_SOURCE_DIR}"
-    --output-directory "${PROJECT_BINARY_DIR}/coverage_html"
-)
-
-add_custom_target(
-    coverage
-    COMMAND ${COVERAGE_TRACE_COMMAND}
-    COMMAND ${COVERAGE_HTML_COMMAND}
-    COMMENT "Generating coverage report"
-    VERBATIM
-)
-
-# TODO
-#=======================================================================
-
-#.PHONY: bench
-#bench:
-#	pdflatex --jobname=echo-f0 benchmarks/benchmarks.tex
-#	pdflatex --jobname=echo-f1 benchmarks/benchmarks.tex
-# pdftoppm {input.pdf} {output.file} -png
+  # Benchmarks. Build them with tests to prevent code rotting
+  add_subdirectory(benchmarks)
 
+  # Examples
+  add_subdirectory(example)
+endif()

CMakePresets.json

@@ -12,7 +12,7 @@
       "warnings": {
         "dev": true,
         "deprecated": true,
-        "uninitialized": true,
+        "uninitialized": false,
         "unusedCli": true,
         "systemVars": false
       },
@@ -52,8 +52,7 @@
         "CMAKE_CXX_COMPILER": "g++-11",
         "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
-        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11",
-        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/g++-11/doc/"
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11"
       }
     },
     {
@@ -69,8 +68,7 @@
         "CMAKE_CXX_COMPILER": "g++-11",
         "CMAKE_SHARED_LINKER_FLAGS": "",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
-        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11-release",
-        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/g++-11-release/doc/"
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11-release"
       }
     },
     {
@@ -86,8 +84,23 @@
         "CMAKE_CXX_COMPILER": "clang++-13",
         "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
-        "PROJECT_BINARY_DIR": "${sourceDir}/build/clang++-13",
-        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/clang++-13/doc/"
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/clang++-13"
+      }
+    },
+    {
+      "name": "clang++-14",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/clang++-14",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra -fsanitize=address",
+        "CMAKE_CXX_COMPILER": "clang++-14",
+        "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/clang++-14"
       }
     },
     {
@@ -104,8 +117,7 @@
         "CMAKE_CXX_COMPILER": "clang++-14",
         "CMAKE_SHARED_LINKER_FLAGS": "",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
-        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp17",
-        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/libc++-14-cpp17/doc/"
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp17"
       }
     },
     {
@@ -122,8 +134,7 @@
         "CMAKE_CXX_COMPILER": "clang++-14",
         "CMAKE_SHARED_LINKER_FLAGS": "",
         "CMAKE_CXX_STANDARD_REQUIRED": "ON",
-        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp20",
-        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/libc++-14-cpp20/doc/"
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp20"
       }
     },
     {
@@ -143,6 +154,7 @@
      { "name": "g++-11", "configurePreset": "g++-11" },
      { "name": "g++-11-release", "configurePreset": "g++-11-release" },
      { "name": "clang++-13", "configurePreset": "clang++-13" },
+     { "name": "clang++-14", "configurePreset": "clang++-14" },
      { "name": "libc++-14-cpp17", "configurePreset": "libc++-14-cpp17" },
      { "name": "libc++-14-cpp20", "configurePreset": "libc++-14-cpp20" },
      { "name": "clang-tidy", "configurePreset": "clang-tidy" }
@@ -158,6 +170,7 @@
      { "name": "g++-11",          "configurePreset": "g++-11",           "inherits": ["test"] },
      { "name": "g++-11-release",  "configurePreset": "g++-11-release",   "inherits": ["test"] },
      { "name": "clang++-13",      "configurePreset": "clang++-13",       "inherits": ["test"] },
+     { "name": "clang++-14",      "configurePreset": "clang++-14",       "inherits": ["test"] },
      { "name": "libc++-14-cpp17", "configurePreset": "libc++-14-cpp17",  "inherits": ["test"] },
      { "name": "libc++-14-cpp20", "configurePreset": "libc++-14-cpp20",  "inherits": ["test"] },
      { "name": "clang-tidy",      "configurePreset": "clang-tidy",       "inherits": ["test"] }

README.md

@@ -1,46 +1,42 @@
-# boost_redis
+# Boost.Redis
 
 Boost.Redis is a high-level [Redis](https://redis.io/) client library built on top of
 [Boost.Asio](https://www.boost.org/doc/libs/release/doc/html/boost_asio.html)
-that implements Redis plain text protocol
+that implements the Redis protocol
 [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md).
-It can multiplex any number of client
-requests, responses, and server pushes onto a single active socket
-connection to the Redis server.  The requirements for using Boost.Redis are
+The requirements for using Boost.Redis are
 
-* Boost 1.81 or greater.
-* C++17 minimum.
+* Boost 1.84 or higher.
+* C++17 or higher.
 * Redis 6 or higher (must support RESP3).
-* Gcc (10, 11, 12), Clang (11, 13, 14) and Visual Studio (16 2019, 17 2022).
+* GCC (11, 12), Clang (11, 13, 14) and Visual Studio (16 2019, 17 2022).
 * Have basic-level knowledge about [Redis](https://redis.io/docs/)
   and [Boost.Asio](https://www.boost.org/doc/libs/1_82_0/doc/html/boost_asio/overview.html).
 
-The latest release can be downloaded on
-https://github.com/boostorg/redis/releases. The library headers can be
-found in the `include` subdirectory and a compilation of the source
+To use the library it is necessary to include
 
 ```cpp
 #include <boost/redis/src.hpp>
 ```
 
-is required. The simplest way to do it is to included this header in
-no more than one source file in your applications. To build the
-examples and tests cmake is supported, for example
+in no more than one source file in your applications. To build the
+examples and tests with cmake run
 
 ```cpp
 # Linux
-$ BOOST_ROOT=/opt/boost_1_81_0 cmake --preset g++-11
+$ BOOST_ROOT=/opt/boost_1_84_0 cmake -S <source-dir> -B <binary-dir>
 
 # Windows 
 $ cmake -G "Visual Studio 17 2022" -A x64 -B bin64 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake
 ```
 
+For more details see https://github.com/boostorg/cmake.
+
 <a name="connection"></a>
 ## Connection
 
-Let us start with a simple application that uses a short-lived
-connection to send a [ping](https://redis.io/commands/ping/) command
-to Redis
+The code below uses a short-lived connection to
+[ping](https://redis.io/commands/ping/) the Redis server 
 
 ```cpp
 auto co_main(config const& cfg) -> net::awaitable<void>
@@ -52,11 +48,11 @@ auto co_main(config const& cfg) -> net::awaitable<void>
    request req;
    req.push("PING", "Hello world");
 
-   // Response where the PONG response will be stored.
+   // Response object.
    response<std::string> resp;
 
    // Executes the request.
-   co_await conn->async_exec(req, resp, net::deferred);
+   co_await conn->async_exec(req, resp);
    conn->cancel();
 
    std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
@@ -82,8 +78,9 @@ them are
 * [Client-side caching](https://redis.io/docs/manual/client-side-caching/)
 
 The connection class supports server pushes by means of the
-`boost::redis::connection::async_receive` function, the coroutine shows how
-to used it
+`boost::redis::connection::async_receive` function, which can be
+called in the same connection that is being used to execute commands.
+The coroutine below shows how to used it
 
 ```cpp
 auto
@@ -92,14 +89,17 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
+   generic_response resp;
+   conn->set_receive_response(resp);
+
    // Loop while reconnection is enabled
    while (conn->will_reconnect()) {
 
       // Reconnect to channels.
-      co_await conn->async_exec(req, ignore, net::deferred);
+      co_await conn->async_exec(req, ignore);
 
       // Loop reading Redis pushes.
-      for (generic_response resp;;) {
+      for (;;) {
          error_code ec;
          co_await conn->async_receive(resp, net::redirect_error(net::use_awaitable, ec));
          if (ec)
@@ -108,7 +108,7 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
          // Use the response resp in some way and then clear it.
          ...
 
-         resp.value().clear();
+         consume_one(resp);
       }
    }
 }
@@ -143,21 +143,18 @@ req.push_range("SUBSCRIBE", std::cbegin(list), std::cend(list));
 req.push_range("HSET", "key", map);
 ```
 
-Sending a request to Redis is performed with `boost::redis::connection::async_exec` as already stated.
-
-### Config flags
-
-The `boost::redis::request::config` object inside the request dictates how the
-`boost::redis::connection` should handle the request in some important situations. The
-reader is advised to read it carefully.
+Sending a request to Redis is performed with `boost::redis::connection::async_exec` as already stated.  The
+`boost::redis::request::config` object inside the request dictates how
+the `boost::redis::connection` the request is handled in some
+situations. The reader is advised to read it carefully.
 
 <a name="responses"></a>
 ## Responses
 
-Boost.Redis uses the following strategy to support Redis responses
+Boost.Redis uses the following strategy to deal with Redis responses
 
-* `boost::redis::request` is used for requests whose number of commands are not dynamic.
-* **Dynamic**: Otherwise use `boost::redis::generic_response`.
+* `boost::redis::request` used for requests whose number of commands are not dynamic.
+* `boost::redis::generic_response` used when the size is dynamic.
 
 For example, the request below has three commands
 
@@ -168,8 +165,8 @@ req.push("INCR", "key");
 req.push("QUIT");
 ```
 
-and its response also has three comamnds and can be read in the
-following response object
+and therefore its response will also contain three elements which can
+be read in the following reponse object
 
 ```cpp
 response<std::string, int, std::string>
@@ -184,7 +181,7 @@ To ignore responses to individual commands in the request use the tag
 
 ```cpp
 // Ignore the second and last responses.
-response<std::string, boost::redis::ignore_t, std::string, boost::redis::ignore_t>
+response<std::string, ignore_t, std::string, ignore_t>
 ```
 
 The following table provides the resp3-types returned by some Redis
@@ -228,7 +225,7 @@ req.push("QUIT");
 
 ```
 
-can be read in the tuple below
+can be read in the response object below
 
 ```cpp
 response<
@@ -241,17 +238,18 @@ response<
 > resp;
 ```
 
-Where both are passed to `async_exec` as showed elsewhere
+Then, to execute the request and read the response use `async_exec` as
+shown below
 
 ```cpp
-co_await conn->async_exec(req, resp, net::deferred);
+co_await conn->async_exec(req, resp);
 ```
 
 If the intention is to ignore responses altogether use `ignore`
 
 ```cpp
 // Ignores the response
-co_await conn->async_exec(req, ignore, net::deferred);
+co_await conn->async_exec(req, ignore);
 ```
 
 Responses that contain nested aggregates or heterogeneous data
@@ -277,15 +275,13 @@ req.push("SUBSCRIBE", "channel");
 req.push("QUIT");
 ```
 
-must be read in this tuple `response<std::string, std::string>`,
-that has static size two.
+must be read in the response object `response<std::string, std::string>`.
 
 ### Null
 
-It is not uncommon for apps to access keys that do not exist or
-that have already expired in the Redis server, to deal with these
-cases Boost.Redis provides support for `std::optional`. To use it,
-wrap your type around `std::optional` like this
+It is not uncommon for apps to access keys that do not exist or that
+have already expired in the Redis server, to deal with these usecases
+wrap the type with an `std::optional` as shown below
 
 ```cpp
 response<
@@ -293,11 +289,9 @@ response<
    std::optional<B>,
    ...
    > resp;
-
-co_await conn->async_exec(req, resp, net::deferred);
 ```
 
-Everything else stays pretty much the same.
+Everything else stays the same.
 
 ### Transactions
 
@@ -319,22 +313,18 @@ use the following response type
 ```cpp
 using boost::redis::ignore;
 
-using exec_resp_type = 
+
+response<
+   ignore_t,  // multi
+   ignore_t,  // QUEUED
+   ignore_t,  // QUEUED
+   ignore_t,  // QUEUED
    response<
       std::optional<std::string>, // get
       std::optional<std::vector<std::string>>, // lrange
       std::optional<std::map<std::string, std::string>> // hgetall
-   >;
-
-response<
-   boost::redis::ignore_t,  // multi
-   boost::redis::ignore_t,  // get
-   boost::redis::ignore_t,  // lrange
-   boost::redis::ignore_t,  // hgetall
-   exec_resp_type,        // exec
+   > // exec
 > resp;
-
-co_await conn->async_exec(req, resp, net::deferred);
 ```
 
 For a complete example see cpp20_containers.cpp.
@@ -348,7 +338,7 @@ commands won't fit in the model presented above, some examples are
 
 * Commands (like `set`) whose responses don't have a fixed
   RESP3 type. Expecting an `int` and receiving a blob-string
-  will result in error.
+  results in an error.
 * RESP3 aggregates that contain nested aggregates can't be read in STL containers.
 * Transactions with a dynamic number of commands can't be read in a `response`.
 
@@ -382,7 +372,7 @@ using other types
 ```cpp
 // Receives any RESP3 simple or aggregate data type.
 boost::redis::generic_response resp;
-co_await conn->async_exec(req, resp, net::deferred);
+co_await conn->async_exec(req, resp);
 ```
 
 For example, suppose we want to retrieve a hash data structure
@@ -409,7 +399,7 @@ the following customization points
 void boost_redis_to_bulk(std::string& to, mystruct const& obj);
 
 // Deserialize
-void boost_redis_from_bulk(mystruct& obj, char const* p, std::size_t size, boost::system::error_code& ec)
+void boost_redis_from_bulk(mystruct& u, node_view const& node, boost::system::error_code&)
 ```
 
 These functions are accessed over ADL and therefore they must be
@@ -445,7 +435,7 @@ main motivations for choosing an echo server are
 
    * Simple to implement and does not require expertise level in most languages.
    * I/O bound: Echo servers have very low CPU consumption in general
-     and  therefore are excelent to  measure how a program handles concurrent requests.
+     and  therefore are excellent to  measure how a program handles concurrent requests.
    * It simulates very well a typical backend in regard to concurrency.
 
 I also imposed some constraints on the implementations
@@ -508,7 +498,7 @@ in the graph, the reasons are
      I don't know for sure why it is so slow, I suppose it has
      something to do with its lack of automatic
      [pipelining](https://redis.io/docs/manual/pipelining/) support.
-     In fact, the more TCP connections I lauch the worse its
+     In fact, the more TCP connections I launch the worse its
      performance gets.
 
    * Libuv: I left it out because it would require me writing to much
@@ -674,7 +664,109 @@ https://lists.boost.org/Archives/boost/2023/01/253944.php.
 
 ## Changelog
 
-### develop (incorporates changes to conform the boost review and more)
+### Boost 1.88
+
+* (Issue [233](https://github.com/boostorg/redis/issues/233))
+  To deal with keys that might not exits in the Redis server, the
+  library supports `std::optional`, for example
+  `response<std::optional<std::vector<std::string>>>`. In some cases
+  however, such as the [MGET](https://redis.io/docs/latest/commands/mget/) command,
+  each element in the vector might be non exiting, now it is possible
+  to specify a response as `response<std::optional<std::vector<std::optional<std::string>>>>`.
+
+* (Issue [225](https://github.com/boostorg/redis/issues/225))
+  Use `deferred` as the connection default completion token.
+
+* (Issue [128](https://github.com/boostorg/redis/issues/128))
+  Adds a new `async_exec` overload that allows passing response
+  adapters. This makes it possible to receive Redis responses directly
+  in custom data structures thereby avoiding uncessary data copying.
+  Thanks to Ruben Perez (@anarthal) for implementing this feature.
+
+* There are also other multiple small improvements in this release,
+  users can refer to the git history for more details.
+
+### Boost 1.87
+
+* (Issue [205](https://github.com/boostorg/redis/issues/205))
+  Improves reaction time to disconnection by using `wait_for_one_error`
+  instead of `wait_for_all`. The function `connection::async_run` was
+  also changed to return EOF to the user when that error is received
+  from the server. That is a breaking change.
+
+* (Issue [210](https://github.com/boostorg/redis/issues/210))
+  Fixes the adapter of empty nested reposponses.
+
+* (Issues [211](https://github.com/boostorg/redis/issues/211) and [212](https://github.com/boostorg/redis/issues/212))
+  Fixes the reconnect loop that would hang under certain conditions,
+  see the linked issues for more details.
+
+* (Issue [219](https://github.com/boostorg/redis/issues/219))
+  Changes the default log level from `disabled` to `debug`.
+
+### Boost 1.85
+
+* (Issue [170](https://github.com/boostorg/redis/issues/170))
+  Under load and on low-latency networks it is possible to start
+  receiving responses before the write operation completed and while
+  the request is still marked as staged and not written. This messes
+  up with the heuristics that classifies responses as unsolicied or
+  not.
+
+* (Issue [168](https://github.com/boostorg/redis/issues/168)).
+  Provides a way of passing a custom SSL context to the connection.
+  The design here differs from that of Boost.Beast and Boost.MySql
+  since in Boost.Redis the connection owns the context instead of only
+  storing a reference to a user provided one. This is ok so because
+  apps need only one connection for their entire application, which
+  makes the overhead of one ssl-context per connection negligible.
+
+* (Issue [181](https://github.com/boostorg/redis/issues/181)).
+  See a detailed description of this bug in
+  [this](https://github.com/boostorg/redis/issues/181#issuecomment-1913346983)
+  comment.
+
+* (Issue [182](https://github.com/boostorg/redis/issues/182)).
+  Sets `"default"` as the default value of `config::username`. This
+  makes it simpler to use the `requirepass` configuration in Redis.
+
+* (Issue [189](https://github.com/boostorg/redis/issues/189)).
+  Fixes narrowing conversion by using `std::size_t` instead of
+  `std::uint64_t` for the sizes of bulks and aggregates. The code
+  relies now on `std::from_chars` returning an error if a value
+  greater than 32 is received on platforms on which the size
+  of `std::size_t` is 32.
+
+
+### Boost 1.84 (First release in Boost)
+
+* Deprecates the `async_receive` overload that takes a response. Users
+  should now first call `set_receive_response` to avoid constantly and
+  unnecessarily setting the same response.
+
+* Uses `std::function` to type erase the response adapter. This change
+  should not influence users in any way but allowed important
+  simplification in the connections internals. This resulted in
+  massive performance improvement.
+
+* The connection has a new member `get_usage()` that returns the
+  connection usage information, such as number of bytes written,
+  received etc.
+
+* There are massive performance improvements in the consuming of
+  server pushes which are now communicated with an `asio::channel` and
+  therefore can be buffered which avoids blocking the socket read-loop.
+  Batch reads are also supported by means of `channel.try_send` and
+  buffered messages can be consumed synchronously with
+  `connection::receive`. The function `boost::redis::cancel_one` has
+  been added to simplify processing multiple server pushes contained
+  in the same `generic_response`.  *IMPORTANT*: These changes may
+  result in more than one push in the response when
+  `connection::async_receive` resumes. The user must therefore be
+  careful when calling `resp.clear()`: either ensure that all message
+  have been processed or just use `consume_one`.
+
+### v1.4.2 (incorporates changes to conform the boost review and more)
 
 * Adds `boost::redis::config::database_index` to make it possible to
   choose a database before starting running commands e.g. after an
@@ -715,7 +807,7 @@ https://lists.boost.org/Archives/boost/2023/01/253944.php.
   would wait for a response to arrive before sending the next one. Now requests
   are continuously coalesced and written to the socket. `request::coalesce`
   became unnecessary and was removed. I could measure significative performance
-  gains with theses changes.
+  gains with these changes.
 
 * Improves serialization examples using Boost.Describe to serialize to JSON and protobuf. See
   cpp20_json.cpp and cpp20_protobuf.cpp for more details.
@@ -922,7 +1014,7 @@ https://lists.boost.org/Archives/boost/2023/01/253944.php.
 * Fixes a bug in the `connection::async_run(host, port)` overload
   that was causing crashes on reconnection.
 
-* Fixes the executor usage in the connection class. Before theses
+* Fixes the executor usage in the connection class. Before these
   changes it was imposing `any_io_executor` on users.
 
 * `connection::async_receiver_event` is not cancelled anymore when

benchmarks/CMakeLists.txt

@@ -0,0 +1,20 @@
+
+add_library(benchmarks_options INTERFACE)
+target_link_libraries(benchmarks_options INTERFACE boost_redis_src)
+target_link_libraries(benchmarks_options INTERFACE boost_redis_project_options)
+target_compile_features(benchmarks_options INTERFACE cxx_std_20)
+
+add_executable(echo_server_client cpp/asio/echo_server_client.cpp)
+target_link_libraries(echo_server_client PRIVATE benchmarks_options)
+
+add_executable(echo_server_direct cpp/asio/echo_server_direct.cpp)
+target_link_libraries(echo_server_direct PRIVATE benchmarks_options)
+
+# TODO
+#=======================================================================
+
+#.PHONY: bench
+#bench:
+#	pdflatex --jobname=echo-f0 benchmarks/benchmarks.tex
+#	pdflatex --jobname=echo-f1 benchmarks/benchmarks.tex
+# pdftoppm {input.pdf} {output.file} -png

build.jam

@@ -0,0 +1,28 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/asio//boost_asio
+    /boost/assert//boost_assert
+    /boost/core//boost_core
+    /boost/mp11//boost_mp11
+    /boost/system//boost_system
+    /boost/throw_exception//boost_throw_exception ;
+
+project /boost/redis
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_redis : : : : <library>$(boost_dependencies) ]
+    [ alias all : boost_redis test ]
+    ;
+
+call-if : boost-library redis
+    ;
+

cmake/BoostRedisConfig.cmake.in

@@ -1,4 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/Aedis.cmake")
-check_required_components("@PROJECT_NAME@")

doc/Jamfile

@@ -0,0 +1,92 @@
+project redis/doc ;
+
+import doxygen ;
+import path ;
+import sequence ;
+
+# All paths must be absolute to work well with the Doxygen rules.
+path-constant this_dir : . ;
+path-constant target_dir : html ;
+path-constant redis_root_dir : .. ;
+path-constant include_dir : ../include ;
+path-constant examples_dir : ../example ;
+path-constant readme : ../README.md ;
+path-constant layout_file : DoxygenLayout.xml ;
+path-constant header : header.html ;
+path-constant footer : footer.html ;
+
+local stylesheet_files = [ path.glob $(this_dir) : *.css ] ;
+local includes = [ path.glob-tree $(include_dir) : *.hpp *.cpp ] ;
+local examples = [ path.glob-tree $(examples_dir) : *.hpp *.cpp ] ;
+
+# If passed directly, several HTML_EXTRA_STYLESHEET tags are generated,
+# which is not correct.
+local stylesheet_arg = [ sequence.join "\"$(stylesheet_files)\"" : " " ] ;
+
+# The doxygen rule requires the target name to end in .html to generate HTML files
+doxygen doc.html
+    :
+        $(includes) $(examples) $(readme)
+    :
+        <doxygen:param>"PROJECT_NAME=Boost.Redis"
+        <doxygen:param>PROJECT_NUMBER="1.84.0"
+        <doxygen:param>PROJECT_BRIEF="A redis client library"
+        <doxygen:param>"STRIP_FROM_PATH=\"$(redis_root_dir)\""
+        <doxygen:param>"STRIP_FROM_INC_PATH=\"$(include_dir)\""
+        <doxygen:param>BUILTIN_STL_SUPPORT=YES
+        <doxygen:param>INLINE_SIMPLE_STRUCTS=YES
+        <doxygen:param>HIDE_UNDOC_MEMBERS=YES
+        <doxygen:param>HIDE_UNDOC_CLASSES=YES
+        <doxygen:param>SHOW_HEADERFILE=YES
+        <doxygen:param>SORT_BRIEF_DOCS=YES
+        <doxygen:param>SORT_MEMBERS_CTORS_1ST=YES
+        <doxygen:param>SHOW_FILES=NO
+        <doxygen:param>SHOW_NAMESPACES=NO
+        <doxygen:param>"LAYOUT_FILE=\"$(layout_file)\""
+        <doxygen:param>WARN_IF_INCOMPLETE_DOC=YES
+        <doxygen:param>FILE_PATTERNS="*.hpp *.cpp"
+        <doxygen:param>EXCLUDE_SYMBOLS=std
+        <doxygen:param>"USE_MDFILE_AS_MAINPAGE=\"$(readme)\""
+        <doxygen:param>SOURCE_BROWSER=YES
+        <doxygen:param>"HTML_HEADER=\"$(header)\""
+        <doxygen:param>"HTML_FOOTER=\"$(footer)\""
+        <doxygen:param>"HTML_EXTRA_STYLESHEET=$(stylesheet_arg)"
+        <doxygen:param>HTML_TIMESTAMP=YES
+        <doxygen:param>GENERATE_TREEVIEW=YES
+        <doxygen:param>FULL_SIDEBAR=YES
+        <doxygen:param>DISABLE_INDEX=YES
+        <doxygen:param>ENUM_VALUES_PER_LINE=0
+        <doxygen:param>OBFUSCATE_EMAILS=YES
+        <doxygen:param>USE_MATHJAX=YES
+        <doxygen:param>MATHJAX_VERSION=MathJax_2
+        <doxygen:param>MATHJAX_RELPATH="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/"
+        <doxygen:param>MACRO_EXPANSION=YES
+        <doxygen:param>HAVE_DOT=NO
+        <doxygen:param>CLASS_GRAPH=NO
+        <doxygen:param>DIRECTORY_GRAPH=NO
+    ;
+
+explicit doc.html ;
+
+# The doxygen rule only informs b2 about the main HTML file, and not about
+# all the doc directory that gets generated. Using the install rule copies
+# only a single file, which is incorrect. This is a workaround to copy
+# the generated docs to the doc/html directory, where they should be.
+make copyhtml.tag : doc.html : @copy_html_dir ;
+explicit copyhtml.tag ;
+actions copy_html_dir
+{
+    rm -rf $(target_dir)
+    mkdir -p $(target_dir)
+    cp -r $(<:D)/html/doc/* $(target_dir)/
+    echo "Stamped" > "$(<)"
+}
+
+# These are used to inform the build system of the
+# means to build the integrated and stand-alone docs.
+
+alias boostdoc ;
+explicit boostdoc ;
+
+alias boostrelease : copyhtml.tag ;
+explicit boostrelease ;

doc/doxygen-awesome-sidebar-only.css

@@ -32,80 +32,104 @@ html {
      * 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;
 }
 
+#page-wrapper {
+    height: calc(100vh - 100px);
+    display: flex;
+    flex-direction: column;
+}
 
-@media screen and (min-width: 768px) {
+#content-wrapper {
+    display: flex;
+    flex-direction: row;
+    min-height: 0;
+}
+
+#doc-content {
+    overflow-y: scroll;
+    flex: 1;
+    height: auto !important;
+}
+
+@media (min-width: 768px) {
     html {
         --searchbar-background: var(--page-background-color);
     }
 
-    #side-nav {
+    #sidebar-wrapper {
+        display: flex;
+        flex-direction: column;
         min-width: var(--side-nav-fixed-width);
-        max-width: var(--side-nav-fixed-width);
-        top: var(--top-height);
-        overflow: visible;
+        max-width: var(--side-nav-fixed-width);   
+        background-color: var(--side-nav-background);
+        border-right: 1px solid rgb(222, 222, 222);
     }
 
-    #nav-tree, #side-nav {
-        height: calc(100vh - var(--top-height)) !important;
+    #search-box-wrapper {
+        display: flex;
+        flex-direction: row;
+        padding-left: 1em;
+        padding-right: 1em;
+    }
+
+    #MSearchBox {
+        flex: 1;
+        display: flex;
+        padding-left: 1em;
+        padding-right: 1em;
+    }
+
+
+    #MSearchBox .left {
+        display: flex;
+        flex: 1;
+        position: static;
+        align-items: center;
+        justify-content: flex-start;
+        width: auto;
+        height: auto;
+    }
+
+    #MSearchBox .right {
+        display: none;
+    }
+
+    #MSearchSelect {
+        padding-left: 0.75em;
+        left: auto;
+        background-repeat: no-repeat;
+    }
+
+    #MSearchField {
+        flex: 1;
+        position: static;
+        width: auto;
+        height: auto;
     }
 
     #nav-tree {
-        padding: 0;
+        height: auto !important;
+    }
+
+    #nav-sync {
+        display: none;
     }
 
     #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 {
@@ -113,3 +137,9 @@ html {
         right: auto;
     }
 }
+
+@media (max-width: 768px) {
+    #sidebar-wrapper {
+        display: none;
+    }
+}

doc/doxygen-awesome.css

@@ -552,25 +552,6 @@ a.anchor {
     margin-top: 0;
 }
 
-/* until Doxygen 1.9.4 */
-.left img#MSearchSelect {
-    left: 0;
-    user-select: none;
-    padding-left: 8px;
-}
-
-/* Doxygen 1.9.5 */
-.left span#MSearchSelect {
-    left: 0;
-    user-select: none;
-    margin-left: 8px;
-    padding: 0;
-}
-
-.left #MSearchSelect[src$=".png"] {
-    padding-left: 0
-}
-
 .SelectionMark {
     user-select: none;
 }
@@ -614,9 +595,7 @@ a.anchor {
 
 #MSearchField {
     font-size: var(--navigation-font-size);
-    height: calc(var(--searchbar-height) - 2px);
     background: transparent;
-    width: calc(var(--searchbar-width) - 64px);
 }
 
 .MSearchBoxActive #MSearchField {

doc/footer.html

@@ -0,0 +1,19 @@
+<!-- HTML footer for doxygen 1.9.1-->
+<!-- start footer part -->
+</div> <!-- close #content-wrapper -->
+<!--BEGIN GENERATE_TREEVIEW-->
+<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
+  <ul>
+    $navpath
+    <li class="footer">$generatedby <a href="https://www.doxygen.org/index.html"><img class="footer" src="$relpath^doxygen.svg" width="104" height="31" alt="doxygen"/></a> $doxygenversion </li>
+  </ul>
+</div>
+<!--END GENERATE_TREEVIEW-->
+<!--BEGIN !GENERATE_TREEVIEW-->
+<hr class="footer"/><address class="footer"><small>
+$generatedby&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="$relpath^doxygen.svg" width="104" height="31" alt="doxygen"/></a> $doxygenversion
+</small></address>
+<!--END !GENERATE_TREEVIEW-->
+</div> <!-- #page-wrapper -->
+</body>
+</html>

doc/header.html

@@ -0,0 +1,61 @@
+<!-- HTML header for doxygen 1.9.1-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://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>
+$treeview
+$search
+$mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
+</head>
+<body>
+<div id="page-wrapper">
+<div id="content-wrapper">
+    <div id="sidebar-wrapper">
+        <div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+            <div id="titlearea">
+                <table cellspacing="0" cellpadding="0">
+                    <tbody>
+                    <tr style="height: 56px;">
+                    <!--BEGIN PROJECT_LOGO-->
+                    <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+                    <!--END PROJECT_LOGO-->
+                    <!--BEGIN PROJECT_NAME-->
+                    <td id="projectalign" style="padding-left: 0.5em;">
+                    <div id="projectname">$projectname
+                    <!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
+                    </div>
+                    <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
+                    </td>
+                    <!--END PROJECT_NAME-->
+                    <!--BEGIN !PROJECT_NAME-->
+                    <!--BEGIN PROJECT_BRIEF-->
+                        <td style="padding-left: 0.5em;">
+                        <div id="projectbrief">$projectbrief</div>
+                        </td>
+                    <!--END PROJECT_BRIEF-->
+                    <!--END !PROJECT_NAME-->
+                    <!--BEGIN DISABLE_INDEX-->
+                    <!--END DISABLE_INDEX-->
+                    </tr>
+                    </tbody>
+                </table>
+            </div>
+            <!--BEGIN SEARCHENGINE-->
+            <div id="search-box-wrapper">
+                $searchbox
+            </div>
+            <!--END SEARCHENGINE-->
+<!--END TITLEAREA-->
+<!-- end header part -->

doc/on-the-costs-of-async-abstractions.md

@@ -0,0 +1,671 @@
+# On the costs of asynchronous abstractions
+
+The biggest force behind the evolution of
+[Boost.Redis](https://github.com/boostorg/redis) was my struggling in
+coming up with a high-level connection abstraction that was capable of
+multiplexing Redis commands from independent sources while
+concurrently handling server pushes. This journey taught me many
+important lessons, many of which are related to the design and
+performance of asynchronous programs based on Boost.Asio.
+
+In this article I will share some of the lessons learned, specially
+those related to the performance costs of _abstractions_ such as
+`async_read_until` that tend to overschedule into the event-loop. In
+this context I will also briefly comment on how the topics discussed
+here influenced my views on the proposed
+[P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
+(a.k.a. Senders and Receivers), which is likely to become the basis of
+networking in upcoming C++ standards.
+
+Although the analysis presented in this article uses the Redis communication
+protocol for illustration I expect it to be useful in general since
+[RESP3](https://github.com/antirez/RESP3/blob/master/spec.md) shares
+many similarities with other widely used protocols such as HTTP. 
+
+## Parsing `\r\n`-delimited messages
+
+The Redis server communicates with its clients by exchanging data
+serialized in
+[RESP3](https://github.com/antirez/RESP3/blob/master/spec.md) format.
+Among the data types supported by this specification, the
+`\r\n`-delimited messages are some of the most frequent in a typical
+session. The table below shows some examples
+
+  Command  | Response | Wire format   | RESP3 name
+  ---------|----------|---------------|---------------------
+  PING     |  PONG    | `+PONG\r\n`   | simple-string
+  INCR     |  42      | `:42\r\n`     | number
+  GET      |  null    | `_\r\n`       | null
+
+Redis also supports command pipelines, which provide a way of
+optimizing round-trip times by batching commands. A pipeline composed
+by the commands shown in the previous table look like this
+
+```
+                       |   Sent in a     |
+                       |   single write  |
++--------+             |                 |              +-------+
+|        | -------->    PING + INCR + GET     --------> |       |
+|        |                                              |       |
+| Client |                                              | Redis |
+|        |                                              |       |
+|        | <-------- "+PONG\r\n:42\r\n_\r\n"  <-------- |       |
++--------+            |<------>|<---->|<-->|            +-------+
+                      |                    |
+                      |     Responses      |
+```
+
+Messages that use delimiters are so common in networking that a
+facility called `async_read_until` for reading them incrementally from
+a socket is already part of Boost.Asio. The coroutine below uses it to
+print message contents to the screen
+
+```cpp
+awaitable<void> parse_resp3_simple_msgs(tcp::socket socket)
+{
+  for (std::string buffer;;) {
+     auto n = co_await async_read_until(socket, dynamic_buffer(buffer), "\r\n");
+
+     std::cout << buffer.substr(1, n - 3) << std::endl;
+
+     // Consume the buffer.
+     buffer.erase(0, n);
+  }
+}
+```
+
+If we pay attention to the buffer content as it is parsed by the code
+above we can see it is rotated fairly often, for example
+
+```
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n"
+   ":100\r\n+OK\r\n_\r\n"
+   "+OK\r\n_\r\n"
+   "_\r\n"
+   ""
+```
+
+When I first realized these, apparently excessive, buffer rotations I
+was concerned they would impact the performance of Boost.Redis in a
+severe way.  To measure the magnitude of this impact I came up with an
+experimental implementation of Asio's `dynamic_buffer` that consumed
+the buffer less eagerly than the `std::string::erase` function used
+above. For that, the implementation increased a buffer offset up
+to a certain threshold and only then triggered a (larger) rotation.
+This is illustrated in the diagram below
+
+```
+    |<---- offset threshold ---->|
+    |                            |
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
+    |                                       # Initial offset
+
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
+    |<------>|                              # After 1st message
+
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
+    |<-------------->|                      # After 2nd message
+
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
+    |<--------------------->|               # After 3rd message
+
+   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
+    |<-------------------------->|          # Threshold crossed after the 4th message
+
+   "+PONG\r\n"
+    |                                       # After rotation
+```
+
+After comparing the performance differences between the two versions I
+was surprised there wasn't any! But that was also very suspicious
+since some RESP3 aggregate types contain a considerable number of
+separators.  For example, a map with two pairs `[(key1, value1),
+(key2, value2)]` encoded in RESP3 requires ten rotations in total
+
+```
+   "%2\r\n$4\r\nkey1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
+   "$4\r\nkey1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
+   "key1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
+   "$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
+   ...
+```
+
+It was evident something more costly was shadowing the buffer
+rotations. But it couldn't be the search for the separator since it
+performs equivalently to rotations. It is also easy to show that the
+overhead is not related to any IO operation since the problem persists
+if the buffer is never consumed (which causes the function to be
+called with the same string repeatedly).  Once these two factors
+are removed from the table, we are driven into the conclusion that
+calling `async_read_until` has an intrinsic cost, let us see what
+that is.
+
+### Async operations that complete synchronously considered harmful
+
+Assume the scenario described earlier where `async_read_until` is used
+to parse multiple `\r\n`-delimited messages. The following is a
+detailed description of what happens behind the scenes
+
+   1. `async_read_until` calls `socket.async_read_some` repeatedly
+      until the separator `\r\n` shows up in the buffer
+
+```
+   "<read1>"                                # Read 1: needs more data.
+   "<read1><read2>"                         # Read 2: needs more data.
+   "<read1><read2>"                         # Read 3: needs more data.
+   "<read1><read2><read3>"                  # Read 4: needs more data.
+   "<read1><read2><read3>\r\n<bonus bytes>" # separator found, done.
+```
+
+   2. The last call to `socket.async_read_some` happens to read past
+      the separator `\r\n` (depicted as `<bonus bytes>` above),
+      resulting in bonus (maybe incomplete) messages in the buffer
+
+```
+    | 1st async_read_some  |         2nd async_read_some            |
+    |                      |                                        |
+    "+message content here \r\n:100\r\n+OK\r\n_\r\n+incomplete respo"
+    |                          |                   |                |
+    |      Message wanted      |<-- bonus msgs --->|<--incomplete-->|
+    |                          |                         msg        |
+    |                          |                                    |
+    |                          |<---------- bonus bytes ----------->|
+```
+
+   3. The buffer is consumed and `async_read_until` is called again.
+      However, since the buffer already contains the next message this
+      is an IO-less call
+
+```
+   ":100\r\n+OK\r\n_\r\n+not enough byt"
+    |                   |              |
+    |  No IO required   | Need more    |
+    |  to parse these   | data         |   
+    |  messages.        |              |
+```
+
+The fact that step 3. doesn't perform any IO implies the operation can
+complete synchronously, but because this is an asynchronous function
+Boost.Asio by default won't call the continuation before the
+function returns. The implementation must therefore enqueue it for
+execution, as depicted below
+
+```
+   OP5 ---> OP4 ---> OP3 ---> OP2 ---> OP1    # Reschedules the continuation
+                                        |
+       OP1 schedules its continuation   |
+    +-----------------------------------+
+    |
+    |
+   OP6 ---> OP5 ---> OP4 ---> OP3 ---> OP2    # Reschedules the continuation
+                                        |
+       OP2 schedules its continuation   |
+    +-----------------------------------+
+    |
+    |
+   OP7 ---> OP6 ---> OP5 ---> OP4 ---> OP3    
+```
+
+When summed up, the excessive rescheduling of continuations lead to
+performance degradation at scale. But since this is an event-loop
+there is no way around rescheduling as doing otherwise would mean
+allowing a task to monopolize the event-loop, preventing other tasks
+from making progress. The best that can be done is to avoid
+_overscheduling_, so let us determine how much rescheduling is too
+much.
+
+## The intrinsic latency of an event-loop 
+
+An event-loop is a design pattern originally used to handle events
+external to the application, such as GUIs, networking and other forms
+of IO.  If we take this literally, it becomes evident that the way
+`async_read_until` works is incompatible with an event-loop since
+_searching for the separator_ is not an external event and as such
+should not have to be enqueued for execution.
+
+Once we constrain ourselves to events that have an external origin,
+such as anything related to IO and including any form of IPC, the
+scheduling overhead is reduced considerably since the latency
+of the transport layer eclipses whatever time it takes to schedule the
+continuation, for example, according to
+[these](https://www.boost.org/doc/libs/develop/libs/cobalt/doc/html/index.html#posting_to_an_executor)
+benchmarks, the time it takes to schedule a task in the
+`asio::io_context ` is approximately `50ns`.
+
+To give the reader an idea about the magnitude of this number, if
+rescheduling alone were to account for 1% of the runtime of an app
+that uses asynchronous IO to move around data in chunks of size 128kb,
+then this app would have a throughput of approximately 24Gbs.  At such
+high throughput multiple other factors kick in before any scheduling
+overhead even starts to manifest.
+
+It is therefore safe to say that only asynchronous operations that
+don't perform or are not bound to any IO are ever likely to
+overschedule in the sense described above. Those cases can be usually
+avoided, this is what worked for Boost.Redis
+
+  1. `async_read_until` was replaced with calls to
+     `socket.async_read_some` and an incremental parser that does not
+     do any IO.
+
+  2. Channel `try_` functions are used to check if send and receive
+     operations can be called without suspension. For example,
+     `try_send` before `async_send` and `try_receive` before
+     `async_receive` ([see also](https://github.com/chriskohlhoff/asio/commit/fe4fd7acf145335eeefdd19708483c46caeb45e5)
+     `try_send_via_dispatch` for a more aggressive optimization).
+
+  3. Coalescing of individual requests into a single payload to reduce
+     the number of necessary writes on the socket, this is only
+     possible because Redis supports pipelining (good protocols
+     help!).
+
+  4. Increased the socket read sizes to 4kb to reduce the number of
+     reads (which is outweighed by the costs of rotating data in the
+     buffer).
+
+  5. Dropped the `resp3::async_read` abstraction. When I started
+     developing Boost.Redis there was convincing precedent for having
+     a `resp3::async_read` function to read complete RESP3 messages
+     from a socket
+
+     Name                                   | Description
+     ---------------------------------------|-------------------
+     `asio::ip::tcp::async_read`            | Reads `n` bytes from a stream.
+     `beast::http::async_read`              | Reads a complete HTTP message.
+     `beast::websocket::stream::async_read` | Reads a complete Websocket message.
+     `redis::async_read`                    | Reads a complete RESP3 message.
+
+     It turns out however that this function is also vulnerable to
+     immediate completions since in command pipelines multiple
+     responses show up in the buffer after a call to
+     `socket.async_read_some`. When that happens each call to
+     `resp3::async_read` is IO-less.
+   
+Sometimes it is not possible to avoid asynchronous operations that
+complete synchronously, in the following sections we will see how to
+favor throughput over fairness in Boost.Asio.
+
+### Calling the continuation inline
+
+In Boost.Asio it is possible to customize how an algorithm executes
+the continuation when an immediate completion occurs, this includes
+the ability of calling it inline, thereby avoiding the costs of
+excessive rescheduling.  Here is how it works
+
+```cpp
+// (default) The continuation is enqueued for execution, regardless of
+// whether it is immediate or not.
+async_read_until(socket, buffer, "\r\n", continuation);
+
+// Immediate completions are executed in exec2 (otherwise equal to the
+// version above). The completion is called inline if exec2 is the
+// same executor that is running the operation.
+async_read_until(socket, buffer, "\r\n", bind_immediate_executor(exec2, completion));
+```
+
+To compare the performance of both cases I have written a small
+function that calls `async_read_until` in a loop with a buffer that is
+never consumed so that all completions are immediate.  The version
+below uses the default behaviour
+
+```cpp
+void read_safe(tcp::socket& s, std::string& buffer)
+{
+   auto continuation = [&s, &buffer](auto ec, auto n)
+   {
+      read_safe(s, buffer); // Recursive call
+   };
+
+   // This won't cause stack exhaustion because the continuation is 
+   // not called inline but posted in the event loop.
+   async_read_until(s, dynamic_buffer(buffer), "\r\n", continuation);
+}
+```
+
+To optimize away some of the rescheduling the version below uses the
+`bind_immediate_executor` customization to call the continuation
+reentrantly and then breaks the stack from time to time to avoid
+exhausting it
+
+```cpp
+void read_reentrant(tcp::socket& s, std::string& buffer)
+{
+   auto cont = [&](auto, auto)
+   {
+      read_reentrant(s, buffer); // Recursive call
+   };
+
+   // Breaks the callstack after 16 inline calls.
+   if (counter % 16 == 0) {
+      post(s.get_executor(), [cont](){cont({}, 0);});
+      return;
+   }
+
+   // Continuation called reentrantly.
+   async_read_until(s, dynamic_buffer(buffer), "\r\n",
+      bind_immediate_executor(s.get_executor(), cont));
+}
+```
+
+The diagram below shows what the reentrant chain of calls in the code
+above look like from the event-loop point of view
+
+```
+   OP5 ---> OP4 ---> OP3 ---> OP2 ---> OP1a    # Completes immediately
+                                        |
+                                        |      
+                 ...                    |
+                                       OP1b    # Completes immediately
+                                        |
+           Waiting for OP5 to           |      
+             reschedule its             |
+             continuation              OP1c    # Completes immediately
+                                        |
+                                        |      
+                 ...                    |
+                                       OP1d    # Break the call-stack
+                                        |
+    +-----------------------------------+     
+    |
+   OP6 ---> OP5 ---> OP4 ---> OP3 ---> OP2
+```
+
+Unsurprisingly, the reentrant code is 3x faster than the one that
+relies on the default behaviour (don't forget that this is a best case
+scenario, in the general case not all completions are immediate).
+Although faster, this strategy has some downsides
+
+   - The overall operation is not as fast as possible since it still
+     has to reschedule from time to time to break the call stack.  The
+     less it reschedules the higher the risk of exhausting it.
+
+   - It is too easy to forget to break the stack. For example, the
+     programmer might decide to branch somewhere into another chain of
+     asynchronous calls that also use this strategy.  To avoid
+     exhaustion all such branches would have to be safeguarded with a
+     manual rescheduling i.e. `post`.
+
+   - Requires additional layers of complexity such as
+     `bind_immediate_executor` in addition to `bind_executor`.
+   
+  - Non-compliat with more strict
+    [guidelines](https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code)
+    that prohibits reentrat code.
+
+   - There is no simple way of choosing the maximum allowed number of
+     reentrant calls for each function in a way that covers different
+     use cases and users. Library writers and users would be tempted
+     into using a small value reducing the performance advantage.
+
+   - If the socket is always ready for reading the task will
+     monopolize IO for up to `16` interactions which might cause
+     stutter in unrelated tasks as depicted below
+
+```
+                                 Unfairness
+
+          +----+----+----+    +----+----+----+    +----+----+----+
+Socket-1  |    |    |    |    |    |    |    |    |    |    |    |
+          +----+----+----+----+----+----+----+----+----+----+----+----+     
+Socket-2                 |    |              |    |              |    | 
+                         +----+              +----+              +----+
+```
+
+From the aesthetic point of view the code above is also unpleasant as
+it breaks the function asynchronous contract by injecting a reentrant
+behaviour. It gives me the same kind of feeling I have about
+[recursive
+mutexes](http://www.zaval.org/resources/library/butenhof1.html).
+
+Note: It is worth mentioning here that a similar
+[strategy](https://github.com/NVIDIA/stdexec/blob/6f23dd5b1d523541ce28af32fc2603403ebd36ed/include/exec/trampoline_scheduler.hpp#L52)
+is used to break the call stack of repeating algorithms in
+[stdexec](https://github.com/NVIDIA/stdexec), but in this time
+based on
+[P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
+and not on Boost.Asio.
+
+### Coroutine tail-calls
+
+In the previous section we have seen how to avoid overscheduling by
+instructing the asynchronous operation to call the completion inline
+on immediate completion.  It turns out however that coroutine support
+for _tail-calls_ provide a way to completely sidestep this problem.
+This feature is described by
+[Lewis Baker](https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer)
+as follows
+
+> A tail-call is one where the current stack-frame is popped before
+> the call and the current function’s return address becomes the
+> return-address for the callee. ie. the callee will return directly
+> the the [sic] caller of this function.
+
+This means (at least in principle) that a library capable of using
+tail-calls when an immediate completion occurs neither has to
+reschedule the continuation nor call it inline. To test how this
+feature compares to the other styles I have used Boost.Cobalt. The
+code looks as follows
+
+```cpp
+// Warning: risks unfairness and starvation of other tasks.
+task<void> read_until_unfair()
+{
+    for (int i = 0; i != repeat; ++i) {
+        co_await async_read_until(s, dynamic_buffer(buffer), "\r\n", cobalt::use_op);
+    }
+}
+```
+
+The result of this comparison as listed in the table below
+
+Time/s | Style     | Configuration               | Library     
+-------|-----------|-----------------------------|-------------
+ 1,0   | Coroutine | `await_ready` optimization  | Boost.Cobalt
+ 4.8   | Callback  | Reentant                    | Boost.Asio  
+10.3   | Coroutine | `use_op`                    | Boost.Cobalt
+14.9   | Callback  | Regular                     | Boost.Asio  
+15.6   | Coroutine | `asio::deferred`            | Boost.Asio  
+
+As the reader can see, `cobalt::use_op` ranks 3rd and is considerably
+faster (10.3 vs 15.6) than the Asio equivalent that uses
+default-rescheduling. However, by trading rescheduling with tail-calls
+the code above can now monopolize the event-loop, resulting in
+unfairness if the socket happens to receive data at a higher rate
+than other tasks. If by chance data is received continuously
+on a socket that is always ready for reading, other tasks will starve
+
+```
+                                 Starvation
+
+          +----+----+----+----+----+----+----+----+----+----+----+----+
+Socket-1  |    |    |    |    |    |    |    |    |    |    |    |    |
+          +----+----+----+----+----+----+----+----+----+----+----+----+     
+
+Socket-2          Starving ...                                          
+                                                                       
+```
+
+To avoid this problem the programmer is forced to reschedule from time
+to time, in the same way we did for the reentrant calls
+
+```cpp
+task<void> read_until_fair()
+{
+    for (int i = 0; i != repeat; ++i) {
+        if (repeat % 16 == 0) {
+            // Reschedules to address unfairness and starvation of 
+            // other tasks.
+            co_await post(cobalt::use_op);
+            continue;
+        }
+        
+        co_await async_read_until(s, dynamic_buffer(buffer), "\r\n", cobalt::use_op);
+    }
+}
+```
+
+Delegating fairness-safety to applications is a dangerous game.
+This is a
+[problem](https://tokio.rs/blog/2020-04-preemption) the Tokio
+community had to deal with before Tokio runtime started enforcing
+rescheduling (after 256 successful operations)
+
+> If data is received faster than it can be processed, it is possible
+> that more data will have already been received by the time the
+> processing of a data chunk completes. In this case, .await will
+> never yield control back to the scheduler, other tasks will not be
+> scheduled, resulting in starvation and large latency variance.
+
+> Currently, the answer to this problem is that the user of Tokio is
+> responsible for adding yield points in both the application and
+> libraries. In practice, very few actually do this and end up being
+> vulnerable to this sort of problem.
+
+### Safety in P2300 (Senders and Receivers)
+
+As of this writing, the C++ standards committee (WG21) has been
+pursuing the standardization of a networking library for almost 20
+years. One of the biggest obstacles that prevented it from happening
+was a disagreement on what the _asynchronous model_ that underlies
+networking should look like. Until 2021 that model was basically
+Boost.Asio _executors_,  but in this
+[poll](https://www.reddit.com/r/cpp/comments/q6tgod/c_committee_polling_results_for_asynchronous/)
+the committee decided to abandon that front and concentrate efforts on
+the new [P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
+proposal, also known as _senders and receivers_. The decision was
+quite [abrupt](https://isocpp.org/files/papers/P2464R0.html)
+
+> The original plan about a week earlier than the actual writing of
+> this paper was to write a paper that makes a case for standardizing
+> the Networking TS.
+
+and opinions turned out to be very strong against Boost.Asio (see
+[this](https://api.csswg.org/bikeshed/?force=1&url=https://raw.githubusercontent.com/brycelelbach/wg21_p2459_2022_january_library_evolution_poll_outcomes/main/2022_january_library_evolution_poll_outcomes.bs)
+for how each voter backed their vote)
+
+> The whole concept is completely useless, there's no composed code
+> you can write with it.
+
+The part of that debate that interests us most here is stated in
+[P2471](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2471r1.pdf),
+that compares Boost.Asio with P2300
+
+> Yes, default rescheduling each operation and default not
+> rescheduling each operation, is a poor trade off. IMO both options
+> are poor. The one good option that I know of that can prevent stack
+> exhaustion is first-class tail-recursion in library or language
+
+> ASIO has chosen to require that every async operation must schedule
+> the completion on a scheduler (every read, every write, etc..).
+
+> sender/receiver has not decided to
+> require that the completion be scheduled. 
+
+> This is why I consider tail-call the only good solution. Scheduling
+> solutions are all inferior (give thanks to Lewis for this shift in
+> my understanding :) ).
+
+Although tail-calls solve the problem of stack-exhaustion as we have
+seen above, it makes the code vulnerable to unfairness and starvation
+and therefore it is not an alternative to default-rescheduling as the
+quotation above is implying.  To deal with the lack of
+default-rescheduling, libraries and applications built on top of P2300
+have to address the aforementioned problems, layer after layer. For
+example,
+[stdexec](https://github.com/NVIDIA/stdexec) has invented something
+called
+_[trampoline-scheduler](https://github.com/NVIDIA/stdexec/blob/e7cd275273525dbc693f4bf5f6dc4d4181b639e4/include/exec/trampoline_scheduler.hpp)_
+to protect repeating algorithms such as `repeat_effect_until` from
+exhausting the stack. This construct however is built around
+reentracy, allowing
+[sixteen](https://github.com/NVIDIA/stdexec/blob/83cdb92d316e8b3bca1357e2cf49fc39e9bed403/include/exec/trampoline_scheduler.hpp#L52)
+levels of inline calls by default. While in Boost.Asio it is possible to use
+reentracy as an optimization for a corner cases, here it is made its
+_modus operandi_, the downsides of this approach have already been stated in a
+previous section so I won't repeat it here.
+
+Also the fact that a special scheduler is needed by specific
+algorithms is a problem on its own since it contradicts one of the
+main selling points of P2300 which is that of being _generic_. For
+example, [P2464R0](https://isocpp.org/files/papers/P2464R0.html) uses
+the code below as an example
+
+```cpp
+void
+run_that_io_operation(
+    scheduler auto sched,
+    sender_of<network_buffer> auto wrapping_continuation)
+{
+   // snip
+}
+```
+
+and states
+
+> I have no idea what the sched's concrete type is. I have no idea
+> what the wrapping_continuation's concrete type is. They're none of
+> my business, ...
+
+Hence, by being generic, the algorithms built on top of P2300 are also
+unsafe (against stack-exhaustion, unfairness and starvation).  Otherwise,
+if library writers require a specific scheduler to ensure safety, then
+the algorithms become automatically non-generic, pick your poison!
+
+The proposers of P2300 claim that it doesn't address safety because it
+should be seen as the low-level building blocks of asynchronous
+programming and that its the role of higher-level libraries, to deal
+with that. This claim however does not hold since, as we have just
+seen, Boost.Asio also provides those building blocks but does so in a
+safe way.  In fact during the whole development of Boost.Redis I never
+had to think about these kinds of problems because safety is built
+from the ground up.
+
+### Avoiding coroutine suspension with `await_ready`
+
+Now let us get back to the first place in the table above, which uses
+the `await_ready` optimization from Boost.Cobalt. This API provides
+users with the ability to avoid coroutine suspension altogether in
+case the separator is already present in the buffer.  It works by
+defining a `struct` with the following interface
+
+```cpp
+struct read_until : cobalt::op<error_code, std::size_t> {
+   ...
+
+   void ready(cobalt::handler<error_code, std::size_t> handler) override
+   {
+      // Search for the separator in buffer and call the handler if found
+   }
+
+   void initiate(cobalt::completion_handler<error_code, std::size_t> complete) override
+   {
+      // Regular call to async_read_until.
+      async_read_until(socket, buffer, delim, std::move(complete));
+   }
+};
+```
+
+and the code that uses it
+
+```cpp
+for (int i = 0; i != repeat; ++i) {
+    co_await read_until(socket, dynamic_buffer(buffer));
+}
+```
+
+In essence, what the code above does is to skip a call to
+`async_read_unil` by first checking with the ready function whether
+the forthcoming operation is going to complete immediately.  The
+nice thing about it is that the programmer can use this optimization
+only when a performance bottleneck is detected, without planing for it
+in advance.  The drawback however is that it requires reimplementing
+the search for the separator in the body of the `ready` function,
+defeating the purpose of using `async_read_until` in first place as
+(again) it would have been simpler to reformulate the operation in
+terms of `socket.async_read_some` directly.
+
+## Acknowledgements
+
+Thanks to Klemens Morgenstern for answering questions about
+Boost.Cobalt.
+

example/CMakeLists.txt

@@ -0,0 +1,52 @@
+add_library(examples_main STATIC main.cpp)
+target_compile_features(examples_main PRIVATE cxx_std_20)
+target_link_libraries(examples_main PRIVATE boost_redis_project_options)
+
+macro(make_example EXAMPLE_NAME STANDARD)
+  add_executable(${EXAMPLE_NAME} ${EXAMPLE_NAME}.cpp)
+  target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_src)
+  target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_project_options)
+  target_compile_features(${EXAMPLE_NAME} PRIVATE cxx_std_${STANDARD})
+  if (${STANDARD} STREQUAL "20")
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE examples_main)
+  endif()
+  if (${EXAMPLE_NAME} STREQUAL "cpp20_json")
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE Boost::json Boost::container_hash)
+  endif()
+endmacro()
+
+macro(make_testable_example EXAMPLE_NAME STANDARD)
+  make_example(${EXAMPLE_NAME} ${STANDARD})
+  if (BOOST_REDIS_INTEGRATION_TESTS)
+    add_test(${EXAMPLE_NAME} ${EXAMPLE_NAME})
+  endif()
+endmacro()
+
+make_testable_example(cpp17_intro 17)
+make_testable_example(cpp17_intro_sync 17)
+
+make_testable_example(cpp20_intro 20)
+make_testable_example(cpp20_containers 20)
+make_testable_example(cpp20_json 20)
+make_testable_example(cpp20_intro_tls 20)
+
+make_example(cpp20_subscriber 20)
+make_example(cpp20_streams 20)
+make_example(cpp20_echo_server 20)
+make_example(cpp20_resolve_with_sentinel 20)
+
+# We test the protobuf example only on gcc.
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  find_package(Protobuf)
+  if (Protobuf_FOUND)
+    protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS person.proto)
+    make_testable_example(cpp20_protobuf 20)
+    target_sources(cpp20_protobuf PUBLIC ${PROTO_SRCS} ${PROTO_HDRS})
+    target_link_libraries(cpp20_protobuf PRIVATE  ${Protobuf_LIBRARIES})
+    target_include_directories(cpp20_protobuf PUBLIC ${Protobuf_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+  endif()
+endif()
+
+if (NOT MSVC)
+  make_example(cpp20_chat_room 20)
+endif()

example/cpp17_intro.cpp

@@ -8,7 +8,7 @@
 #include <boost/asio/detached.hpp>
 #include <iostream>
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
 using boost::redis::connection;
 using boost::redis::request;
 using boost::redis::response;
@@ -29,10 +29,10 @@ auto main(int argc, char * argv[]) -> int
 
       response<std::string> resp;
 
-      net::io_context ioc;
+      asio::io_context ioc;
       connection conn{ioc};
 
-      conn.async_run(cfg, {}, net::detached);
+      conn.async_run(cfg, {}, asio::detached);
 
       conn.async_exec(req, resp, [&](auto ec, auto) {
          if (!ec)

example/cpp17_intro_sync.cpp

@@ -9,7 +9,6 @@
 #include <string>
 #include <iostream>
 
-namespace net = boost::asio;
 using boost::redis::sync_connection;
 using boost::redis::request;
 using boost::redis::response;

example/cpp20_chat_room.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/signal_set.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
@@ -17,16 +16,22 @@
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
 
-namespace net = boost::asio;
-using stream_descriptor = net::deferred_t::as_default_on_t<net::posix::stream_descriptor>;
-using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
-using boost::redis::request;
-using boost::redis::generic_response;
+namespace asio = boost::asio;
+using asio::posix::stream_descriptor;
+using asio::signal_set;
+using boost::asio::async_read_until;
+using boost::asio::awaitable;
+using boost::asio::co_spawn;
+using boost::asio::consign;
+using boost::asio::detached;
+using boost::asio::dynamic_buffer;
+using boost::asio::redirect_error;
+using boost::asio::use_awaitable;
 using boost::redis::config;
 using boost::redis::connection;
+using boost::redis::generic_response;
 using boost::redis::ignore;
-using net::redirect_error;
-using net::use_awaitable;
+using boost::redis::request;
 using boost::system::error_code;
 using namespace std::chrono_literals;
 
@@ -34,20 +39,22 @@ using namespace std::chrono_literals;
 // terminals and type messages to stdin.
 
 auto
-receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+receiver(std::shared_ptr<connection> conn) -> awaitable<void>
 {
    request req;
    req.push("SUBSCRIBE", "channel");
 
+   generic_response resp;
+   conn->set_receive_response(resp);
+
    while (conn->will_reconnect()) {
 
       // Subscribe to channels.
-      co_await conn->async_exec(req, ignore, net::deferred);
+      co_await conn->async_exec(req, ignore);
 
       // Loop reading Redis push messages.
-      for (generic_response resp;;) {
-         error_code ec;
-         co_await conn->async_receive(resp, redirect_error(use_awaitable, ec));
+      for (error_code ec;;) {
+         co_await conn->async_receive(redirect_error(use_awaitable, ec));
          if (ec)
             break; // Connection lost, break so we can reconnect to channels.
          std::cout
@@ -61,27 +68,27 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 }
 
 // Publishes stdin messages to a Redis channel.
-auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection> conn) -> awaitable<void>
 {
    for (std::string msg;;) {
-      auto n = co_await net::async_read_until(*in, net::dynamic_buffer(msg, 1024), "\n");
+      auto n = co_await async_read_until(*in, dynamic_buffer(msg, 1024), "\n");
       request req;
       req.push("PUBLISH", "channel", msg);
-      co_await conn->async_exec(req, ignore, net::deferred);
+      co_await conn->async_exec(req, ignore);
       msg.erase(0, n);
    }
 }
 
 // Called from the main function (see main.cpp)
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> awaitable<void>
 {
-   auto ex = co_await net::this_coro::executor;
+   auto ex = co_await asio::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
    auto stream = std::make_shared<stream_descriptor>(ex, ::dup(STDIN_FILENO));
 
-   net::co_spawn(ex, receiver(conn), net::detached);
-   net::co_spawn(ex, publisher(stream, conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   co_spawn(ex, receiver(conn), detached);
+   co_spawn(ex, publisher(stream, conn), detached);
+   conn->async_run(cfg, {}, consign(detached, conn));
 
    signal_set sig_set{ex, SIGINT, SIGTERM};
    co_await sig_set.async_wait();
@@ -90,7 +97,7 @@ auto co_main(config cfg) -> net::awaitable<void>
 }
 
 #else // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-auto co_main(config const&) -> net::awaitable<void>
+auto co_main(config const&) -> awaitable<void>
 {
    std::cout << "Requires support for posix streams." << std::endl;
    co_return;

example/cpp20_containers.cpp

@@ -0,0 +1,140 @@
+/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <map>
+#include <vector>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+namespace asio = boost::asio;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::ignore_t;
+using boost::redis::ignore;
+using boost::redis::config;
+using boost::redis::connection;
+using boost::asio::awaitable;
+using boost::asio::detached;
+using boost::asio::consign;
+
+template<class T>
+std::ostream& operator<<(std::ostream& os, std::optional<T> const& opt)
+{
+    if (opt.has_value())
+        std::cout << opt.value();
+    else
+        std::cout << "null";
+
+    return os;
+}
+
+void print(std::map<std::string, std::string> const& cont)
+{
+   for (auto const& e: cont)
+      std::cout << e.first << ": " << e.second << "\n";
+}
+
+template <class T>
+void print(std::vector<T> const& cont)
+{
+   for (auto const& e: cont) std::cout << e << " ";
+   std::cout << "\n";
+}
+
+// Stores the content of some STL containers in Redis.
+auto store(std::shared_ptr<connection> conn) -> 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"}};
+
+   request req;
+   req.push_range("RPUSH", "rpush-key", vec);
+   req.push_range("HSET", "hset-key", map);
+   req.push("SET", "key", "value");
+
+   co_await conn->async_exec(req, ignore);
+}
+
+auto hgetall(std::shared_ptr<connection> conn) -> awaitable<void>
+{
+   // A request contains multiple commands.
+   request req;
+   req.push("HGETALL", "hset-key");
+
+   // Responses as tuple elements.
+   response<std::map<std::string, std::string>> resp;
+
+   // Executes the request and reads the response.
+   co_await conn->async_exec(req, resp);
+
+   print(std::get<0>(resp).value());
+}
+
+auto mget(std::shared_ptr<connection> conn) -> awaitable<void>
+{
+   // A request contains multiple commands.
+   request req;
+   req.push("MGET", "key", "non-existing-key");
+
+   // Responses as tuple elements.
+   response<std::vector<std::optional<std::string>>> resp;
+
+   // Executes the request and reads the response.
+   co_await conn->async_exec(req, resp);
+
+   print(std::get<0>(resp).value());
+}
+
+// Retrieves in a transaction.
+auto transaction(std::shared_ptr<connection> conn) -> awaitable<void>
+{
+   request req;
+   req.push("MULTI");
+   req.push("LRANGE", "rpush-key", 0, -1); // Retrieves
+   req.push("HGETALL", "hset-key"); // Retrieves
+   req.push("MGET", "key", "non-existing-key");
+   req.push("EXEC");
+
+   response<
+      ignore_t, // multi
+      ignore_t, // lrange
+      ignore_t, // hgetall
+      ignore_t, // mget
+      response<
+         std::optional<std::vector<int>>,
+         std::optional<std::map<std::string, std::string>>,
+         std::optional<std::vector<std::optional<std::string>>>
+      > // exec
+   > resp;
+
+   co_await conn->async_exec(req, resp);
+
+   print(std::get<0>(std::get<4>(resp).value()).value().value());
+   print(std::get<1>(std::get<4>(resp).value()).value().value());
+   print(std::get<2>(std::get<4>(resp).value()).value().value());
+}
+
+// Called from the main function (see main.cpp)
+awaitable<void> co_main(config cfg)
+{
+   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
+   conn->async_run(cfg, {}, consign(detached, conn));
+
+   co_await store(conn);
+   co_await transaction(conn);
+   co_await hgetall(conn);
+   co_await mget(conn);
+   conn->cancel();
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

example/cpp20_echo_server.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/signal_set.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/redirect_error.hpp>
@@ -14,10 +13,8 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
-using tcp_socket = net::deferred_t::as_default_on_t<net::ip::tcp::socket>;
-using tcp_acceptor = net::deferred_t::as_default_on_t<net::ip::tcp::acceptor>;
-using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+namespace asio = boost::asio;
+using boost::asio::signal_set;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
@@ -25,16 +22,19 @@ using boost::system::error_code;
 using boost::redis::connection;
 using namespace std::chrono_literals;
 
-auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto
+echo_server_session(
+   asio::ip::tcp::socket socket,
+   std::shared_ptr<connection> conn) -> asio::awaitable<void>
 {
    request req;
    response<std::string> resp;
 
    for (std::string buffer;;) {
-      auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
+      auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(buffer, 1024), "\n");
       req.push("PING", buffer);
-      co_await conn->async_exec(req, resp, net::deferred);
-      co_await net::async_write(socket, net::buffer(std::get<0>(resp).value()));
+      co_await conn->async_exec(req, resp);
+      co_await asio::async_write(socket, asio::buffer(std::get<0>(resp).value()));
       std::get<0>(resp).value().clear();
       req.clear();
       buffer.erase(0, n);
@@ -42,25 +42,25 @@ auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) ->
 }
 
 // Listens for tcp connections.
-auto listener(std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto listener(std::shared_ptr<connection> conn) -> asio::awaitable<void>
 {
    try {
-      auto ex = co_await net::this_coro::executor;
-      tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
+      auto ex = co_await asio::this_coro::executor;
+      asio::ip::tcp::acceptor acc(ex, {asio::ip::tcp::v4(), 55555});
       for (;;)
-         net::co_spawn(ex, echo_server_session(co_await acc.async_accept(), conn), net::detached);
+         asio::co_spawn(ex, echo_server_session(co_await acc.async_accept(), conn), asio::detached);
    } catch (std::exception const& e) {
       std::clog << "Listener: " << e.what() << std::endl;
    }
 }
 
 // Called from the main function (see main.cpp)
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> asio::awaitable<void>
 {
-   auto ex = co_await net::this_coro::executor;
+   auto ex = co_await asio::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
-   net::co_spawn(ex, listener(conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   asio::co_spawn(ex, listener(conn), asio::detached);
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    signal_set sig_set(ex, SIGINT, SIGTERM);
    co_await sig_set.async_wait();

example/cpp20_intro.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/consign.hpp>
@@ -13,17 +12,17 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
 using boost::redis::connection;
 
 // Called from the main function (see main.cpp)
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> asio::awaitable<void>
 {
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    // A request containing only a ping command.
    request req;
@@ -33,7 +32,7 @@ auto co_main(config cfg) -> net::awaitable<void>
    response<std::string> resp;
 
    // Executes the request.
-   co_await conn->async_exec(req, resp, net::deferred);
+   co_await conn->async_exec(req, resp);
    conn->cancel();
 
    std::cout << "PING: " << std::get<0>(resp).value() << std::endl;

example/cpp20_intro_tls.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/use_awaitable.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/consign.hpp>
@@ -13,20 +12,20 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
 using boost::redis::logger;
 using boost::redis::connection;
 
-auto verify_certificate(bool, net::ssl::verify_context&) -> bool
+auto verify_certificate(bool, asio::ssl::verify_context&) -> bool
 {
    std::cout << "set_verify_callback" << std::endl;
    return true;
 }
 
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> asio::awaitable<void>
 {
    cfg.use_ssl = true;
    cfg.username = "aedis";
@@ -34,18 +33,18 @@ auto co_main(config cfg) -> net::awaitable<void>
    cfg.addr.host = "db.occase.de";
    cfg.addr.port = "6380";
 
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    request req;
    req.push("PING");
 
    response<std::string> resp;
 
-   conn->next_layer().set_verify_mode(net::ssl::verify_peer);
+   conn->next_layer().set_verify_mode(asio::ssl::verify_peer);
    conn->next_layer().set_verify_callback(verify_certificate);
 
-   co_await conn->async_exec(req, resp, net::deferred);
+   co_await conn->async_exec(req, resp);
    conn->cancel();
 
    std::cout << "Response: " << std::get<0>(resp).value() << std::endl;

example/cpp20_json.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/describe.hpp>
 #include <boost/asio/consign.hpp>
@@ -15,21 +14,21 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-#define BOOST_JSON_NO_LIB
-#define BOOST_CONTAINER_NO_LIB
 #include <boost/json/serialize.hpp>
 #include <boost/json/parse.hpp>
 #include <boost/json/value_from.hpp>
+#include <boost/json/value_to.hpp>
 #include <boost/redis/resp3/serialization.hpp>
-#include <boost/json/src.hpp>
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
+namespace resp3 = boost::redis::resp3;
 using namespace boost::describe;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
 using boost::redis::config;
 using boost::redis::connection;
+using boost::redis::resp3::node_view;
 
 // Struct that will be stored in Redis using json serialization. 
 struct user {
@@ -41,18 +40,26 @@ struct user {
 // The type must be described for serialization to work.
 BOOST_DESCRIBE_STRUCT(user, (), (name, age, country))
 
-// Boost.Redis customization points (examples/json.hpp)
+// Boost.Redis customization points (example/json.hpp)
 void boost_redis_to_bulk(std::string& to, user const& u)
-   { boost::redis::resp3::boost_redis_to_bulk(to, boost::json::serialize(boost::json::value_from(u))); }
-
-void boost_redis_from_bulk(user& u, std::string_view sv, boost::system::error_code&)
-   { u = boost::json::value_to<user>(boost::json::parse(sv)); }
-
-auto co_main(config cfg) -> net::awaitable<void>
 {
-   auto ex = co_await net::this_coro::executor;
+   resp3::boost_redis_to_bulk(to, boost::json::serialize(boost::json::value_from(u)));
+}
+
+void
+boost_redis_from_bulk(
+   user& u,
+   node_view const& node,
+   boost::system::error_code&)
+{
+   u = boost::json::value_to<user>(boost::json::parse(node.value));
+}
+
+auto co_main(config cfg) -> asio::awaitable<void>
+{
+   auto ex = co_await asio::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    // user object that will be stored in Redis in json format.
    user const u{"Joao", "58", "Brazil"};
@@ -64,7 +71,7 @@ auto co_main(config cfg) -> net::awaitable<void>
 
    response<ignore_t, user> resp;
 
-   co_await conn->async_exec(req, resp, net::deferred);
+   co_await conn->async_exec(req, resp);
    conn->cancel();
 
    // Prints the first ping

example/cpp20_protobuf.cpp

@@ -6,7 +6,6 @@
 
 #include <boost/redis/connection.hpp>
 #include <boost/redis/resp3/serialization.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/consign.hpp>
@@ -19,18 +18,20 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
+namespace resp3 = boost::redis::resp3;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::operation;
 using boost::redis::ignore_t;
 using boost::redis::config;
 using boost::redis::connection;
+using boost::redis::resp3::node_view;
 
-// The protobuf type described in examples/person.proto
+// The protobuf type described in example/person.proto
 using tutorial::person;
 
-// Boost.Redis customization points (examples/protobuf.hpp)
+// Boost.Redis customization points (example/protobuf.hpp)
 namespace tutorial
 {
 
@@ -43,12 +44,16 @@ void boost_redis_to_bulk(std::string& to, person const& u)
    if (!u.SerializeToString(&tmp))
       throw boost::system::system_error(boost::redis::error::invalid_data_type);
 
-   boost::redis::resp3::boost_redis_to_bulk(to, tmp);
+   resp3::boost_redis_to_bulk(to, tmp);
 }
 
-void boost_redis_from_bulk(person& u, std::string_view sv, boost::system::error_code& ec)
+void
+boost_redis_from_bulk(
+   person& u,
+   node_view const& node,
+   boost::system::error_code& ec)
 {
-   std::string const tmp {sv};
+   std::string const tmp {node.value};
    if (!u.ParseFromString(tmp))
       ec = boost::redis::error::invalid_data_type;
 }
@@ -58,11 +63,11 @@ void boost_redis_from_bulk(person& u, std::string_view sv, boost::system::error_
 using tutorial::boost_redis_to_bulk;
 using tutorial::boost_redis_from_bulk;
 
-net::awaitable<void> co_main(config cfg)
+asio::awaitable<void> co_main(config cfg)
 {
-   auto ex = co_await net::this_coro::executor;
+   auto ex = co_await asio::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    person p;
    p.set_name("Louis");
@@ -76,7 +81,7 @@ net::awaitable<void> co_main(config cfg)
    response<ignore_t, person> resp;
 
    // Sends the request and receives the response.
-   co_await conn->async_exec(req, resp, net::deferred);
+   co_await conn->async_exec(req, resp);
    conn->cancel();
 
    std::cout

example/cpp20_resolve_with_sentinel.cpp

@@ -12,8 +12,8 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
-using endpoints = net::ip::tcp::resolver::results_type;
+namespace asio = boost::asio;
+using endpoints = asio::ip::tcp::resolver::results_type;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
@@ -22,18 +22,18 @@ using boost::redis::address;
 using boost::redis::connection;
 
 auto redir(boost::system::error_code& ec)
-   { return net::redirect_error(net::use_awaitable, ec); }
+   { return asio::redirect_error(asio::use_awaitable, ec); }
 
 // 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& addresses) -> net::awaitable<address>
+auto resolve_master_address(std::vector<address> const& addresses) -> asio::awaitable<address>
 {
    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);
+   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
 
    response<std::optional<std::array<std::string, 2>>, ignore_t> resp;
    for (auto addr : addresses) {
@@ -43,7 +43,7 @@ auto resolve_master_address(std::vector<address> const& addresses) -> net::await
       // TODO: async_run and async_exec should be lauched in
       // parallel here so we can wait for async_run completion
       // before eventually calling it again.
-      conn->async_run(cfg, {}, net::consign(net::detached, conn));
+      conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
       co_await conn->async_exec(req, resp, redir(ec));
       conn->cancel();
       conn->reset_stream();
@@ -54,7 +54,7 @@ auto resolve_master_address(std::vector<address> const& addresses) -> net::await
    co_return address{};
 }
 
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> asio::awaitable<void>
 {
    // A list of sentinel addresses from which only one is responsive.
    // This simulates sentinels that are down.

example/cpp20_streams.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/consign.hpp>
@@ -26,7 +25,7 @@ using boost::redis::generic_response;
 using boost::redis::operation;
 using boost::redis::request;
 using boost::redis::connection;
-using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+using net::signal_set;
 
 auto stream_reader(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
@@ -39,7 +38,7 @@ auto stream_reader(std::shared_ptr<connection> conn) -> net::awaitable<void>
 
     for (;;) {
         req.push("XREAD", "BLOCK", "0", "STREAMS", "test-topic", stream_id);
-        co_await conn->async_exec(req, resp, net::deferred);
+        co_await conn->async_exec(req, resp);
 
         //std::cout << "Response: ";
         //for (auto i = 0UL; i < resp->size(); ++i) {

example/cpp20_subscriber.cpp

@@ -8,7 +8,6 @@
 #include <boost/redis/logger.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/use_awaitable.hpp>
-#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/consign.hpp>
@@ -18,16 +17,18 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
 using namespace std::chrono_literals;
 using boost::redis::request;
 using boost::redis::generic_response;
+using boost::redis::consume_one;
 using boost::redis::logger;
 using boost::redis::config;
 using boost::redis::ignore;
+using boost::redis::error;
 using boost::system::error_code;
 using boost::redis::connection;
-using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+using asio::signal_set;
 
 /* This example will subscribe and read pushes indefinitely.
  *
@@ -47,39 +48,49 @@ using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
 
 // Receives server pushes.
 auto
-receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+receiver(std::shared_ptr<connection> conn) -> asio::awaitable<void>
 {
    request req;
    req.push("SUBSCRIBE", "channel");
 
+   generic_response resp;
+   conn->set_receive_response(resp);
+
    // Loop while reconnection is enabled
    while (conn->will_reconnect()) {
 
-      // Reconnect to channels.
-      co_await conn->async_exec(req, ignore, net::deferred);
+      // Reconnect to the channels.
+      co_await conn->async_exec(req, ignore);
 
       // Loop reading Redis pushs messages.
-      for (generic_response resp;;) {
-         error_code ec;
-         co_await conn->async_receive(resp, net::redirect_error(net::use_awaitable, ec));
+      for (error_code ec;;) {
+         // First tries to read any buffered pushes.
+         conn->receive(ec);
+         if (ec == error::sync_receive_push_failed) {
+            ec = {};
+            co_await conn->async_receive(asio::redirect_error(asio::use_awaitable, ec));
+         }
+
          if (ec)
             break; // Connection lost, break so we can reconnect to channels.
+
          std::cout
             << resp.value().at(1).value
             << " " << resp.value().at(2).value
             << " " << resp.value().at(3).value
             << std::endl;
-         resp.value().clear();
+
+         consume_one(resp);
       }
    }
 }
 
-auto co_main(config cfg) -> net::awaitable<void>
+auto co_main(config cfg) -> asio::awaitable<void>
 {
-   auto ex = co_await net::this_coro::executor;
+   auto ex = co_await asio::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
-   net::co_spawn(ex, receiver(conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+   asio::co_spawn(ex, receiver(conn), asio::detached);
+   conn->async_run(cfg, {}, asio::consign(asio::detached, conn));
 
    signal_set sig_set(ex, SIGINT, SIGTERM);
    co_await sig_set.async_wait();

example/main.cpp

@@ -11,13 +11,13 @@
 #include <boost/asio/io_context.hpp>
 #include <iostream>
 
-namespace net = boost::asio;
+namespace asio = boost::asio;
 using boost::redis::config;
 using boost::redis::logger;
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
-extern net::awaitable<void> co_main(config);
+extern asio::awaitable<void> co_main(config);
 
 auto main(int argc, char * argv[]) -> int
 {
@@ -29,8 +29,8 @@ auto main(int argc, char * argv[]) -> int
          cfg.addr.port = argv[2];
       }
 
-      net::io_context ioc;
-      net::co_spawn(ioc, std::move(co_main(cfg)), [](std::exception_ptr p) {
+      asio::io_context ioc;
+      asio::co_spawn(ioc, co_main(cfg), [](std::exception_ptr p) {
          if (p)
             std::rethrow_exception(p);
       });

example/sync_connection.hpp

@@ -1,5 +1,5 @@
 
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

examples/cpp20_containers.cpp

@@ -1,102 +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 <boost/redis/connection.hpp>
-#include <boost/asio/deferred.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <map>
-#include <vector>
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace net = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::ignore_t;
-using boost::redis::ignore;
-using boost::redis::config;
-using boost::redis::connection;
-
-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";
-}
-
-// 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"}};
-
-   request req;
-   req.push_range("RPUSH", "rpush-key", vec);
-   req.push_range("HSET", "hset-key", map);
-
-   co_await conn->async_exec(req, ignore, net::deferred);
-}
-
-auto hgetall(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
-   // A request contains multiple commands.
-   request req;
-   req.push("HGETALL", "hset-key");
-
-   // Responses as tuple elements.
-   response<std::map<std::string, std::string>> resp;
-
-   // Executes the request and reads the response.
-   co_await conn->async_exec(req, resp, net::deferred);
-
-   print(std::get<0>(resp).value());
-}
-
-// Retrieves in a transaction.
-auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
-   request req;
-   req.push("MULTI");
-   req.push("LRANGE", "rpush-key", 0, -1); // Retrieves
-   req.push("HGETALL", "hset-key"); // Retrieves
-   req.push("EXEC");
-
-   response<
-      ignore_t, // multi
-      ignore_t, // lrange
-      ignore_t, // hgetall
-      response<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>> // exec
-   > resp;
-
-   co_await conn->async_exec(req, resp, net::deferred);
-
-   print(std::get<0>(std::get<3>(resp).value()).value().value());
-   print(std::get<1>(std::get<3>(resp).value()).value().value());
-}
-
-// Called from the main function (see main.cpp)
-net::awaitable<void> co_main(config cfg)
-{
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
-
-   co_await store(conn);
-   co_await transaction(conn);
-   co_await hgetall(conn);
-   conn->cancel();
-}
-
-#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)

include/boost/redis.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/adapter/adapt.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/adapter/any_adapter.hpp

@@ -0,0 +1,80 @@
+/* Copyright (c) 2018-2023 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_ANY_ADAPTER_HPP
+#define BOOST_REDIS_ANY_ADAPTER_HPP
+
+
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/adapter/adapt.hpp>
+#include <boost/system/error_code.hpp>
+#include <cstddef>
+#include <functional>
+#include <string_view>
+#include <type_traits>
+
+namespace boost::redis {
+
+namespace detail { 
+
+// Forward decl
+template <class Executor>
+class basic_connection;
+
+}
+
+/** @brief A type-erased reference to a response.
+ *  @ingroup high-level-api
+ *
+ *  A type-erased response adapter. It can be executed using @ref connection::async_exec.
+ *  Using this type instead of raw response references enables separate compilation.
+ *
+ *  Given a response object `resp` that can be passed to `async_exec`, the following two
+ *  statements have the same effect:
+ *  ```
+ *      co_await conn.async_exec(req, resp);
+ *      co_await conn.async_exec(req, any_response(resp));
+ *  ```
+ */
+class any_adapter
+{
+    using fn_type = std::function<void(std::size_t, resp3::basic_node<std::string_view> const&, system::error_code&)>;
+
+    struct impl_t {
+        fn_type adapt_fn;
+        std::size_t supported_response_size;
+    } impl_;
+
+    template <class T>
+    static auto create_impl(T& resp) -> impl_t
+    {
+        using namespace boost::redis::adapter;
+        auto adapter = boost_redis_adapt(resp);
+        std::size_t size = adapter.get_supported_response_size();
+        return { std::move(adapter), size };
+    }
+
+    template <class Executor>
+    friend class basic_connection;
+
+public:
+    /**
+     * @brief Constructor.
+     * 
+     * Creates a type-erased response adapter from `resp` by calling
+     * `boost_redis_adapt`. `T` must be a valid Redis response type.
+     * Any type passed to @ref connection::async_exec qualifies.
+     *
+     * This object stores a reference to `resp`, which must be kept alive
+     * while `*this` is being used.
+     */
+    template <class T, class = std::enable_if_t<!std::is_same_v<T, any_adapter>>>
+    explicit any_adapter(T& resp) : impl_(create_impl(resp)) {}
+};
+
+}
+
+#endif

include/boost/redis/adapter/detail/adapters.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -29,7 +29,6 @@
 #include <charconv>
 
 // See https://stackoverflow.com/a/31658120/1077832
-#include<ciso646>
 #ifdef _LIBCPP_VERSION
 #else
 #include <cstdlib>
@@ -38,49 +37,120 @@
 namespace boost::redis::adapter::detail
 {
 
-// Serialization.
+template <class> struct is_integral : std::false_type {};
 
-template <class T>
-auto boost_redis_from_bulk(T& i, std::string_view sv, system::error_code& ec) -> typename std::enable_if<std::is_integral<T>::value, void>::type
-{
-   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
-   if (res.ec != std::errc())
-      ec = redis::error::not_a_number;
-}
+template <> struct is_integral<long long int         > : std::true_type {};
+template <> struct is_integral<unsigned long long int> : std::true_type {};
+template <> struct is_integral<int                   > : std::true_type {};
 
-inline
-void boost_redis_from_bulk(bool& t, std::string_view sv, system::error_code&)
-{
-   t = *sv.data() == 't';
-}
+template<class T, bool = is_integral<T>::value>
+struct converter;
 
-inline
-void boost_redis_from_bulk(double& d, std::string_view sv, system::error_code& ec)
-{
+template<class T>
+struct converter<T, true> {
+   template <class String>
+   static void
+   apply(
+      T& i,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      auto const res =
+         std::from_chars(node.value.data(), node.value.data() + node.value.size(), i);
+      if (res.ec != std::errc())
+         ec = redis::error::not_a_number;
+   }
+};
+
+template<>
+struct converter<bool, false> {
+   template <class String>
+   static void
+   apply(
+      bool& t,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      t = *node.value.data() == 't';
+   }
+};
+
+template<>
+struct converter<double, false> {
+   template <class String>
+   static void
+   apply(
+      double& d,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
 #ifdef _LIBCPP_VERSION
-   // The string in sv is not null terminated and we also don't know
-   // if there is enough space at the end for a null char. The easiest
-   // thing to do is to create a temporary.
-   std::string const tmp{sv.data(), sv.data() + std::size(sv)};
-   char* end{};
-   d = std::strtod(tmp.data(), &end);
-   if (d == HUGE_VAL || d == 0)
-      ec = redis::error::not_a_double;
+      // The string in node.value is not null terminated and we also
+      // don't know if there is enough space at the end for a null
+      // char. The easiest thing to do is to create a temporary.
+      std::string const tmp{node.value.data(), node.value.data() + node.value.size()};
+      char* end{};
+      d = std::strtod(tmp.data(), &end);
+      if (d == HUGE_VAL || d == 0)
+         ec = redis::error::not_a_double;
 #else
-   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), d);
-   if (res.ec != std::errc())
-      ec = redis::error::not_a_double;
+      auto const res = std::from_chars(node.value.data(), node.value.data() + node.value.size(), d);
+      if (res.ec != std::errc())
+         ec = redis::error::not_a_double;
 #endif // _LIBCPP_VERSION
-}
+   }
+};
 
 template <class CharT, class Traits, class Allocator>
+struct converter<std::basic_string<CharT, Traits, Allocator>, false> {
+   template <class String>
+   static void
+   apply(
+      std::basic_string<CharT, Traits, Allocator>& s,
+      resp3::basic_node<String> const& node,
+      system::error_code&)
+   {
+      s.append(node.value.data(), node.value.size());
+   }
+};
+
+template <class T>
+struct from_bulk_impl {
+   template <class String>
+   static void
+   apply(
+      T& t,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      converter<T>::apply(t, node, ec);
+   }
+};
+
+template <class T>
+struct from_bulk_impl<std::optional<T>> {
+   template <class String>
+   static void
+   apply(
+      std::optional<T>& op,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      if (node.data_type != resp3::type::null) {
+         op.emplace(T{});
+         converter<T>::apply(op.value(), node, ec);
+      }
+   }
+};
+
+template <class T, class String>
 void
 boost_redis_from_bulk(
-   std::basic_string<CharT, Traits, Allocator>& s,
-   std::string_view sv,
-   system::error_code&)
+  T& t,
+  resp3::basic_node<String> const& node,
+  system::error_code& ec)
 {
-  s.append(sv.data(), sv.size());
+   from_bulk_impl<T>::apply(t, node, ec);
 }
 
 //================================================
@@ -92,7 +162,8 @@ private:
 
 public:
    explicit general_aggregate(Result* c = nullptr): result_(c) {}
-   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code&)
+   template <class String>
+   void operator()(resp3::basic_node<String> const& nd, system::error_code&)
    {
       BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
       switch (nd.data_type) {
@@ -114,7 +185,8 @@ private:
 public:
    explicit general_simple(Node* t = nullptr) : result_(t) {}
 
-   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code&)
+   template <class String>
+   void operator()(resp3::basic_node<String> const& nd, system::error_code&)
    {
       BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
       switch (nd.data_type) {
@@ -136,18 +208,15 @@ class simple_impl {
 public:
    void on_value_available(Result&) {}
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& n,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& node, system::error_code& ec)
    {
-      if (is_aggregate(n.data_type)) {
+      if (is_aggregate(node.data_type)) {
          ec = redis::error::expects_resp3_simple_type;
          return;
       }
 
-      boost_redis_from_bulk(result, n.value, ec);
+      boost_redis_from_bulk(result, node, ec);
    }
 };
 
@@ -160,11 +229,8 @@ public:
    void on_value_available(Result& result)
       { hint_ = std::end(result); }
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       if (is_aggregate(nd.data_type)) {
          if (nd.data_type != resp3::type::set)
@@ -180,7 +246,7 @@ public:
       }
 
       typename Result::key_type obj;
-      boost_redis_from_bulk(obj, nd.value, ec);
+      boost_redis_from_bulk(obj, nd, ec);
       hint_ = result.insert(hint_, std::move(obj));
    }
 };
@@ -195,11 +261,8 @@ public:
    void on_value_available(Result& result)
       { current_ = std::end(result); }
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       if (is_aggregate(nd.data_type)) {
          if (element_multiplicity(nd.data_type) != 2)
@@ -216,11 +279,11 @@ public:
 
       if (on_key_) {
          typename Result::key_type obj;
-         boost_redis_from_bulk(obj, nd.value, ec);
+         boost_redis_from_bulk(obj, nd, ec);
          current_ = result.insert(current_, {std::move(obj), {}});
       } else {
          typename Result::mapped_type obj;
-         boost_redis_from_bulk(obj, nd.value, ec);
+         boost_redis_from_bulk(obj, nd, ec);
          current_->second = std::move(obj);
       }
 
@@ -233,18 +296,15 @@ class vector_impl {
 public:
    void on_value_available(Result& ) { }
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       if (is_aggregate(nd.data_type)) {
          auto const m = element_multiplicity(nd.data_type);
          result.reserve(result.size() + m * nd.aggregate_size);
       } else {
          result.push_back({});
-         boost_redis_from_bulk(result.back(), nd.value, ec);
+         boost_redis_from_bulk(result.back(), nd, ec);
       }
    }
 };
@@ -257,11 +317,8 @@ private:
 public:
    void on_value_available(Result& ) { }
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       if (is_aggregate(nd.data_type)) {
 	 if (i_ != -1) {
@@ -280,7 +337,7 @@ public:
          }
 
          BOOST_ASSERT(nd.aggregate_size == 1);
-         boost_redis_from_bulk(result.at(i_), nd.value, ec);
+         boost_redis_from_bulk(result.at(i_), nd, ec);
       }
 
       ++i_;
@@ -292,11 +349,8 @@ struct list_impl {
 
    void on_value_available(Result& ) { }
 
-   void
-   operator()(
-      Result& result,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       if (!is_aggregate(nd.data_type)) {
         BOOST_ASSERT(nd.aggregate_size == 1);
@@ -306,7 +360,7 @@ struct list_impl {
         }
 
         result.push_back({});
-        boost_redis_from_bulk(result.back(), nd.value, ec);
+        boost_redis_from_bulk(result.back(), nd, ec);
       }
    }
 };
@@ -357,15 +411,17 @@ struct impl_map<std::deque<T, Allocator>> { using type = list_impl<std::deque<T,
 template <class>
 class wrapper;
 
-template <class Result>
-class wrapper<result<Result>> {
+template <class T>
+class wrapper<result<T>> {
 public:
-   using response_type = result<Result>;
+   using response_type = result<T>;
 private:
    response_type* result_;
-   typename impl_map<Result>::type impl_;
+   typename impl_map<T>::type impl_;
+   bool called_once_ = false;
 
-   bool set_if_resp3_error(resp3::basic_node<std::string_view> const& nd) noexcept
+   template <class String>
+   bool set_if_resp3_error(resp3::basic_node<String> const& nd) noexcept
    {
       switch (nd.data_type) {
          case resp3::type::null:
@@ -382,22 +438,20 @@ public:
    explicit wrapper(response_type* t = nullptr) : result_(t)
    {
       if (result_) {
-         result_->value() = Result{};
+         result_->value() = T{};
          impl_.on_value_available(result_->value());
       }
    }
 
-   void
-   operator()(
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
 
       if (result_->has_error())
          return;
 
-      if (set_if_resp3_error(nd))
+      if (!std::exchange(called_once_, true) && set_if_resp3_error(nd))
          return;
 
       BOOST_ASSERT(result_);
@@ -413,8 +467,10 @@ public:
 private:
    response_type* result_;
    typename impl_map<T>::type impl_{};
+   bool called_once_ = false;
 
-   bool set_if_resp3_error(resp3::basic_node<std::string_view> const& nd) noexcept
+   template <class String>
+   bool set_if_resp3_error(resp3::basic_node<String> const& nd) noexcept
    {
       switch (nd.data_type) {
          case resp3::type::blob_error:
@@ -429,9 +485,10 @@ private:
 public:
    explicit wrapper(response_type* o = nullptr) : result_(o) {}
 
+   template <class String>
    void
    operator()(
-      resp3::basic_node<std::string_view> const& nd,
+      resp3::basic_node<String> const& nd,
       system::error_code& ec)
    {
       BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
@@ -442,7 +499,7 @@ public:
       if (set_if_resp3_error(nd))
          return;
 
-      if (nd.data_type == resp3::type::null)
+      if (!std::exchange(called_once_, true) && nd.data_type == resp3::type::null)
          return;
 
       if (!result_->value().has_value()) {

include/boost/redis/adapter/detail/response_traits.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -23,8 +23,8 @@ namespace boost::redis::adapter::detail
 
 class ignore_adapter {
 public:
-   void
-   operator()(std::size_t, resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+   template <class String>
+   void operator()(std::size_t, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       switch (nd.data_type) {
          case resp3::type::simple_error: ec = redis::error::resp3_simple_error; break;
@@ -59,11 +59,8 @@ public:
    auto get_supported_response_size() const noexcept
       { return size;}
 
-   void
-   operator()(
-      std::size_t i,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(std::size_t i, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       using std::visit;
       // I am usure whether this should be an error or an assertion.
@@ -88,11 +85,8 @@ public:
    get_supported_response_size() const noexcept
       { return static_cast<std::size_t>(-1);}
 
-   void
-   operator()(
-      std::size_t,
-      resp3::basic_node<std::string_view> const& nd,
-      system::error_code& ec)
+   template <class String>
+   void operator()(std::size_t, resp3::basic_node<String> const& nd, system::error_code& ec)
    {
       adapter_(nd, ec);
    }
@@ -142,7 +136,8 @@ class wrapper {
 public:
    explicit wrapper(Adapter adapter) : adapter_{adapter} {}
 
-   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+   template <class String>
+   void operator()(resp3::basic_node<String> const& nd, system::error_code& ec)
       { return adapter_(0, nd, ec); }
 
    [[nodiscard]]

include/boost/redis/adapter/detail/result_traits.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -30,7 +30,7 @@ namespace boost::redis::adapter::detail
  */
 template <class Result>
 struct result_traits {
-   using adapter_type = adapter::detail::wrapper<typename std::decay<Result>::type>;
+   using adapter_type = wrapper<typename std::decay<Result>::type>;
    static auto adapt(Result& r) noexcept { return adapter_type{&r}; }
 };
 
@@ -102,8 +102,12 @@ private:
                std::variant>,
          std::tuple_size<Tuple>::value>;
 
+   // Tuple element we are currently on.
    std::size_t i_ = 0;
+
+   // Nested aggregate element counter.
    std::size_t aggregate_size_ = 0;
+
    adapters_array_type adapters_;
    result<Tuple>* res_ = nullptr;
 
@@ -116,35 +120,36 @@ public:
       }
    }
 
-   void count(resp3::basic_node<std::string_view> const& nd)
+   template <class String>
+   void count(resp3::basic_node<String> const& elem)
    {
-      if (nd.depth == 1) {
-         if (is_aggregate(nd.data_type))
-            aggregate_size_ = element_multiplicity(nd.data_type) * nd.aggregate_size;
-         else
-            ++i_;
-
-         return;
+      if (elem.depth == 1 && is_aggregate(elem.data_type)) {
+         aggregate_size_ = element_multiplicity(elem.data_type) * elem.aggregate_size;
       }
 
-      if (--aggregate_size_ == 0)
-         ++i_;
+      if (aggregate_size_ == 0) {
+         i_ += 1;
+      } else {
+         aggregate_size_ -= 1;
+      }
    }
 
-   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+   template <class String>
+   void operator()(resp3::basic_node<String> const& elem, system::error_code& ec)
    {
       using std::visit;
 
-      if (nd.depth == 0) {
-         auto const real_aggr_size = nd.aggregate_size * element_multiplicity(nd.data_type);
+      if (elem.depth == 0) {
+         auto const multiplicity = element_multiplicity(elem.data_type);
+         auto const real_aggr_size = elem.aggregate_size * multiplicity;
          if (real_aggr_size != std::tuple_size<Tuple>::value)
             ec = redis::error::incompatible_size;
 
          return;
       }
 
-      visit([&](auto& arg){arg(nd, ec);}, adapters_[i_]);
-      count(nd);
+      visit([&](auto& arg){arg(elem, ec);}, adapters_[i_]);
+      count(elem);
    }
 };
 

include/boost/redis/adapter/ignore.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/adapter/result.hpp

@@ -1,5 +1,5 @@
 
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/config.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -38,7 +38,7 @@ struct config {
     * [HELLO](https://redis.io/commands/hello/) command.  If left
     * empty `HELLO` will be sent without authentication parameters.
     */
-   std::string username;
+   std::string username = "default";
 
    /** @brief Password passed to the
     * [HELLO](https://redis.io/commands/hello/) command.  If left

include/boost/redis/detail/connection_base.hpp

@@ -1,920 +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 BOOST_REDIS_CONNECTION_BASE_HPP
-#define BOOST_REDIS_CONNECTION_BASE_HPP
-
-#include <boost/redis/adapter/adapt.hpp>
-#include <boost/redis/detail/helper.hpp>
-#include <boost/redis/detail/read.hpp>
-#include <boost/redis/error.hpp>
-#include <boost/redis/operation.hpp>
-#include <boost/redis/request.hpp>
-#include <boost/redis/resp3/type.hpp>
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/runner.hpp>
-
-#include <boost/system.hpp>
-#include <boost/asio/basic_stream_socket.hpp>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
-#include <boost/asio/write.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/ignore_unused.hpp>
-#include <boost/asio/ssl/stream.hpp>
-#include <boost/asio/read_until.hpp>
-#include <boost/asio/buffer.hpp>
-
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <deque>
-#include <memory>
-#include <string_view>
-#include <type_traits>
-
-namespace boost::redis::detail {
-
-template <class Conn>
-struct wait_receive_op {
-   Conn* conn_;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void
-   operator()(Self& self , system::error_code ec = {})
-   {
-      BOOST_ASIO_CORO_REENTER (coro)
-      {
-         conn_->read_op_timer_.cancel();
-
-         BOOST_ASIO_CORO_YIELD
-         conn_->read_op_timer_.async_wait(std::move(self));
-         if (!conn_->is_open() || is_cancelled(self)) {
-            self.complete(!!ec ? ec : asio::error::operation_aborted);
-            return;
-         }
-         self.complete({});
-      }
-   }
-};
-
-template <class Conn, class Adapter>
-class read_next_op {
-public:
-   using req_info_type = typename Conn::req_info;
-   using req_info_ptr = typename std::shared_ptr<req_info_type>;
-
-private:
-   Conn* conn_;
-   req_info_ptr info_;
-   Adapter adapter_;
-   std::size_t cmds_ = 0;
-   std::size_t read_size_ = 0;
-   std::size_t index_ = 0;
-   asio::coroutine coro_{};
-
-public:
-   read_next_op(Conn& conn, Adapter adapter, req_info_ptr info)
-   : conn_{&conn}
-   , info_{info}
-   , adapter_{adapter}
-   , cmds_{info->get_number_of_commands()}
-   {}
-
-   auto make_adapter() noexcept
-   {
-      return [i = index_, adpt = adapter_] (resp3::basic_node<std::string_view> const& nd, system::error_code& ec) mutable { adpt(i, nd, ec); };
-   }
-
-   template <class Self>
-   void
-   operator()( Self& self
-             , system::error_code ec = {}
-             , std::size_t n = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro_)
-      {
-         // Loop reading the responses to this request.
-         while (cmds_ != 0) {
-            if (info_->stop_requested()) {
-               self.complete(asio::error::operation_aborted, 0);
-               return;
-            }
-
-            //-----------------------------------
-            // If we detect a push in the middle of a request we have
-            // to hand it to the push consumer. To do that we need
-            // some data in the read bufer.
-            if (conn_->read_buffer_.empty()) {
-
-               if (conn_->use_ssl()) {
-                  BOOST_ASIO_CORO_YIELD
-                  asio::async_read_until(conn_->next_layer(), conn_->dbuf_, resp3::parser::sep, std::move(self));
-               } else {
-                  BOOST_ASIO_CORO_YIELD
-                  asio::async_read_until(conn_->next_layer().next_layer(), conn_->dbuf_, resp3::parser::sep, std::move(self));
-               }
-
-               BOOST_REDIS_CHECK_OP1(conn_->cancel(operation::run););
-               if (info_->stop_requested()) {
-                  self.complete(asio::error::operation_aborted, 0);
-                  return;
-               }
-            }
-
-            // 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) {
-               BOOST_ASIO_CORO_YIELD
-               conn_->async_wait_receive(std::move(self));
-               BOOST_REDIS_CHECK_OP1(conn_->cancel(operation::run););
-               continue;
-            }
-            //-----------------------------------
-
-            if (conn_->use_ssl()) {
-               BOOST_ASIO_CORO_YIELD
-               redis::detail::async_read(conn_->next_layer(), conn_->dbuf_, make_adapter(), std::move(self));
-            } else {
-               BOOST_ASIO_CORO_YIELD
-               redis::detail::async_read(conn_->next_layer().next_layer(), conn_->dbuf_, make_adapter(), std::move(self));
-            }
-
-            ++index_;
-
-            if (ec || redis::detail::is_cancelled(self)) {
-               conn_->cancel(operation::run);
-               self.complete(!!ec ? ec : asio::error::operation_aborted, {});
-               return;
-            }
-
-            conn_->dbuf_.consume(n);
-            read_size_ += n;
-
-            BOOST_ASSERT(cmds_ != 0);
-            --cmds_;
-         }
-
-         self.complete({}, read_size_);
-      }
-   }
-};
-
-template <class Conn, class Adapter>
-struct receive_op {
-   Conn* conn_;
-   Adapter adapter;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void
-   operator()( Self& self
-             , system::error_code ec = {}
-             , std::size_t n = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro)
-      {
-         if (!conn_->is_next_push()) {
-            BOOST_ASIO_CORO_YIELD
-            conn_->read_op_timer_.async_wait(std::move(self));
-            if (!conn_->is_open() || is_cancelled(self)) {
-               self.complete(!!ec ? ec : asio::error::operation_aborted, 0);
-               return;
-            }
-         }
-
-         if (conn_->use_ssl()) {
-            BOOST_ASIO_CORO_YIELD
-            redis::detail::async_read(conn_->next_layer(), conn_->dbuf_, adapter, std::move(self));
-         } else {
-            BOOST_ASIO_CORO_YIELD
-            redis::detail::async_read(conn_->next_layer().next_layer(), conn_->dbuf_, adapter, std::move(self));
-         }
-
-         if (ec || is_cancelled(self)) {
-            conn_->cancel(operation::run);
-            conn_->cancel(operation::receive);
-            self.complete(!!ec ? ec : asio::error::operation_aborted, {});
-            return;
-         }
-
-         conn_->dbuf_.consume(n);
-
-         if (!conn_->is_next_push()) {
-            conn_->read_op_timer_.cancel();
-         }
-
-         self.complete({}, n);
-         return;
-      }
-   }
-};
-
-template <class Conn, class Adapter>
-struct exec_op {
-   using req_info_type = typename Conn::req_info;
-
-   Conn* conn = nullptr;
-   request const* req = nullptr;
-   Adapter adapter{};
-   std::shared_ptr<req_info_type> info = nullptr;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void
-   operator()( Self& self
-             , system::error_code ec = {}
-             , std::size_t n = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro)
-      {
-         // Check whether the user wants to wait for the connection to
-         // be stablished.
-         if (req->get_config().cancel_if_not_connected && !conn->is_open()) {
-            BOOST_ASIO_CORO_YIELD
-            asio::post(std::move(self));
-            return self.complete(error::not_connected, 0);
-         }
-
-         info = std::allocate_shared<req_info_type>(asio::get_associated_allocator(self), *req, conn->get_executor());
-
-         conn->add_request_info(info);
-EXEC_OP_WAIT:
-         BOOST_ASIO_CORO_YIELD
-         info->async_wait(std::move(self));
-         BOOST_ASSERT(ec == asio::error::operation_aborted);
-
-         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()) {
-               using c_t = 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;
-            }
-         }
-
-         BOOST_ASSERT(conn->is_open());
-          
-         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_ASIO_CORO_YIELD
-         conn->async_read_next(adapter, std::move(self));
-         BOOST_REDIS_CHECK_OP1(;);
-
-         if (info->stop_requested()) {
-            // Don't have to call remove_request as it has already
-            // been by cancel(exec).
-            return self.complete(ec, 0);
-         }
-
-         BOOST_ASSERT(!conn->reqs_.empty());
-         conn->reqs_.pop_front();
-
-         if (conn->is_waiting_response()) {
-            BOOST_ASSERT(!conn->reqs_.empty());
-            conn->reqs_.front()->proceed();
-         } else {
-            conn->read_timer_.cancel_one();
-         }
-
-         self.complete({}, n);
-      }
-   }
-};
-
-template <class Conn, class Logger>
-struct run_op {
-   Conn* conn = nullptr;
-   Logger logger_;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , system::error_code ec0 = {}
-                  , system::error_code ec1 = {})
-   {
-      BOOST_ASIO_CORO_REENTER (coro)
-      {
-         conn->write_buffer_.clear();
-         conn->read_buffer_.clear();
-
-         BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token) { return conn->reader(token);},
-            [this](auto token) { return conn->writer(logger_, token);}
-         ).async_wait(
-            asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
-
-         switch (order[0]) {
-           case 0: self.complete(ec0); break;
-           case 1: self.complete(ec1); break;
-           default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <class Conn, class Logger>
-struct writer_op {
-   Conn* conn_;
-   Logger logger_;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      ignore_unused(n);
-
-      BOOST_ASIO_CORO_REENTER (coro) for (;;)
-      {
-         while (conn_->coalesce_requests()) {
-            if (conn_->use_ssl())
-               BOOST_ASIO_CORO_YIELD asio::async_write(conn_->next_layer(), asio::buffer(conn_->write_buffer_), std::move(self));
-            else
-               BOOST_ASIO_CORO_YIELD asio::async_write(conn_->next_layer().next_layer(), asio::buffer(conn_->write_buffer_), std::move(self));
-
-            logger_.on_write(ec, conn_->write_buffer_);
-            BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run););
-
-            conn_->on_write();
-
-            // A socket.close() may have been called while a
-            // successful write might had already been queued, so we
-            // have to check here before proceeding.
-            if (!conn_->is_open()) {
-               self.complete({});
-               return;
-            }
-         }
-
-         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
-            // success.
-            self.complete({});
-            return;
-         }
-      }
-   }
-};
-
-template <class Conn>
-struct reader_op {
-   Conn* conn;
-   asio::coroutine coro{};
-
-   bool as_push() const
-   {
-      return
-         (resp3::to_type(conn->read_buffer_.front()) == resp3::type::push)
-          || conn->reqs_.empty()
-          || (!conn->reqs_.empty() && conn->reqs_.front()->get_number_of_commands() == 0)
-          || !conn->is_waiting_response(); // Added to deal with MONITOR.
-   }
-
-   template <class Self>
-   void operator()( Self& self
-                  , system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      ignore_unused(n);
-
-      BOOST_ASIO_CORO_REENTER (coro) for (;;)
-      {
-         if (conn->use_ssl())
-            BOOST_ASIO_CORO_YIELD asio::async_read_until(conn->next_layer(), conn->dbuf_, "\r\n", std::move(self));
-         else
-            BOOST_ASIO_CORO_YIELD asio::async_read_until(conn->next_layer().next_layer(), conn->dbuf_, "\r\n", std::move(self));
-
-         if (ec == asio::error::eof) {
-            conn->cancel(operation::run);
-            return self.complete({}); // EOFINAE: EOF is not an error.
-         }
-
-         BOOST_REDIS_CHECK_OP0(conn->cancel(operation::run););
-
-         // We handle unsolicited events in the following way
-         //
-         // 1. Its resp3 type is a push.
-         //
-         // 2. A non-push type is received with an empty requests
-         //    queue. I have noticed this is possible (e.g. -MISCONF).
-         //    I expect them to have type push so we can distinguish
-         //    them from responses to commands, but it is a
-         //    simple-error. If we are lucky enough to receive them
-         //    when the command queue is empty we can treat them as
-         //    server pushes, otherwise it is impossible to handle
-         //    them properly
-         //
-         // 3. The request does not expect any response but we got
-         //    one. This may happen if for example, subscribe with
-         //    wrong syntax.
-         //
-         // Useful links:
-         //
-         // - https://github.com/redis/redis/issues/11784
-         // - https://github.com/redis/redis/issues/6426
-         //
-         BOOST_ASSERT(!conn->read_buffer_.empty());
-         if (as_push()) {
-            BOOST_ASIO_CORO_YIELD
-            conn->async_wait_receive(std::move(self));
-         } else {
-            BOOST_ASSERT_MSG(conn->is_waiting_response(), "Not waiting for a response (using MONITOR command perhaps?)");
-            BOOST_ASSERT(!conn->reqs_.empty());
-            BOOST_ASSERT(conn->reqs_.front()->get_number_of_commands() != 0);
-            conn->reqs_.front()->proceed();
-            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(asio::error::basic_errors::operation_aborted);
-            return;
-         }
-      }
-   }
-};
-
-/** @brief Base class for high level Redis asynchronous connections.
- *  @ingroup high-level-api
- *
- *  @tparam Executor The executor type.
- *
- */
-template <class Executor>
-class connection_base {
-public:
-   /// Executor type
-   using executor_type = Executor;
-
-   /// Type of the next layer
-   using next_layer_type = asio::ssl::stream<asio::basic_stream_socket<asio::ip::tcp, Executor>>;
-
-   using this_type = connection_base<Executor>;
-
-   /// Constructs from an executor.
-   connection_base(
-      executor_type ex,
-      asio::ssl::context::method method,
-      std::size_t max_read_size)
-   : ctx_{method}
-   , stream_{std::make_unique<next_layer_type>(ex, ctx_)}
-   , writer_timer_{ex}
-   , read_timer_{ex}
-   , read_op_timer_{ex}
-   , runner_{ex, {}}
-   , dbuf_{read_buffer_, max_read_size}
-   {
-      writer_timer_.expires_at(std::chrono::steady_clock::time_point::max());
-      read_timer_.expires_at(std::chrono::steady_clock::time_point::max());
-      read_op_timer_.expires_at(std::chrono::steady_clock::time_point::max());
-   }
-
-   /// Returns the ssl context.
-   auto const& get_ssl_context() const noexcept
-      { return ctx_;}
-
-   /// Returns the ssl context.
-   auto& get_ssl_context() noexcept
-      { return ctx_;}
-
-   /// Resets the underlying stream.
-   void reset_stream()
-   {
-      stream_ = std::make_unique<next_layer_type>(writer_timer_.get_executor(), ctx_);
-   }
-
-   /// Returns a reference to the next layer.
-   auto& next_layer() noexcept { return *stream_; }
-
-   /// Returns a const reference to the next layer.
-   auto const& next_layer() const noexcept { return *stream_; }
-
-   /// Returns the associated executor.
-   auto get_executor() {return writer_timer_.get_executor();}
-
-   /// Cancels specific operations.
-   virtual void cancel(operation op)
-   {
-      runner_.cancel(op);
-      if (op == operation::all) {
-         cancel_impl(operation::run);
-         cancel_impl(operation::receive);
-         cancel_impl(operation::exec);
-         return;
-      } 
-
-      cancel_impl(op);
-   }
-
-   template <class Response, class CompletionToken>
-   auto async_exec(request const& req, Response& resp, CompletionToken token)
-   {
-      using namespace boost::redis::adapter;
-      auto f = boost_redis_adapt(resp);
-      BOOST_ASSERT_MSG(req.size() <= f.get_supported_response_size(), "Request and response have incompatible sizes.");
-
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code, std::size_t)
-         >(redis::detail::exec_op<this_type, decltype(f)>{this, &req, f}, token, writer_timer_);
-   }
-
-   template <class Response, class CompletionToken>
-   auto async_receive(Response& response, CompletionToken token)
-   {
-      using namespace boost::redis::adapter;
-      auto g = boost_redis_adapt(response);
-      auto f = adapter::detail::make_adapter_wrapper(g);
-
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code, std::size_t)
-         >(redis::detail::receive_op<this_type, decltype(f)>{this, f}, token, read_op_timer_);
-   }
-
-   template <class Logger, class CompletionToken>
-   auto async_run(config const& cfg, Logger l, CompletionToken token)
-   {
-      runner_.set_config(cfg);
-      l.set_prefix(runner_.get_config().log_prefix);
-      return runner_.async_run(*this, l, std::move(token));
-   }
-
-private:
-   using clock_type = std::chrono::steady_clock;
-   using clock_traits_type = asio::wait_traits<clock_type>;
-   using timer_type = asio::basic_waitable_timer<clock_type, clock_traits_type, executor_type>;
-   using runner_type = redis::detail::runner<executor_type>;
-
-   auto use_ssl() const noexcept
-      { return runner_.get_config().use_ssl;}
-
-   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->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);
-
-      auto const ret = std::distance(point, std::end(reqs_));
-
-      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
-         ptr->stop();
-      });
-
-      reqs_.erase(point, std::end(reqs_));
-      std::for_each(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
-         return ptr->reset_status();
-      });
-
-      return ret;
-   }
-
-   auto cancel_unwritten_requests() -> std::size_t
-   {
-      auto f = [](auto const& ptr)
-      {
-         BOOST_ASSERT(ptr != nullptr);
-         return ptr->is_written();
-      };
-
-      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), f);
-
-      auto const ret = std::distance(point, std::end(reqs_));
-
-      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
-         ptr->stop();
-      });
-
-      reqs_.erase(point, std::end(reqs_));
-      return ret;
-   }
-
-   void cancel_impl(operation op)
-   {
-      switch (op) {
-         case operation::exec:
-         {
-            cancel_unwritten_requests();
-         } break;
-         case operation::run:
-         {
-            close();
-            read_timer_.cancel();
-            writer_timer_.cancel();
-            cancel_on_conn_lost();
-         } break;
-         case operation::receive:
-         {
-            read_op_timer_.cancel();
-         } break;
-         default: /* ignore */;
-      }
-   }
-
-   void on_write()
-   {
-      // We have to clear the payload right after writing it to use it
-      // as a flag that informs there is no ongoing write.
-      write_buffer_.clear();
-
-      // Notice this must come before the for-each below.
-      cancel_push_requests();
-
-      // There is small optimization possible here: traverse only the
-      // partition of unwritten requests instead of them all.
-      std::for_each(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
-         BOOST_ASSERT_MSG(ptr != nullptr, "Expects non-null pointer.");
-         if (ptr->is_staged())
-            ptr->mark_written();
-      });
-   }
-
-   struct req_info {
-   public:
-      enum class action
-      {
-         stop,
-         proceed,
-         none,
-      };
-
-      explicit req_info(request const& req, executor_type ex)
-      : timer_{ex}
-      , action_{action::none}
-      , req_{&req}
-      , cmds_{std::size(req)}
-      , status_{status::none}
-      {
-         timer_.expires_at(std::chrono::steady_clock::time_point::max());
-      }
-
-      auto proceed()
-      {
-         timer_.cancel();
-         action_ = action::proceed;
-      }
-
-      void stop()
-      {
-         timer_.cancel();
-         action_ = action::stop;
-      }
-
-      [[nodiscard]] auto is_waiting_write() const noexcept
-         { return !is_written() && !is_staged(); }
-
-      [[nodiscard]] auto is_written() const noexcept
-         { return status_ == status::written; }
-
-      [[nodiscard]] auto is_staged() const noexcept
-         { return status_ == status::staged; }
-
-      void mark_written() noexcept
-         { status_ = status::written; }
-
-      void mark_staged() noexcept
-         { status_ = status::staged; }
-
-      void reset_status() noexcept
-         { status_ = status::none; }
-
-      [[nodiscard]] auto get_number_of_commands() const noexcept
-         { return cmds_; }
-
-      [[nodiscard]] auto get_request() const noexcept -> auto const&
-         { return *req_; }
-
-      [[nodiscard]] auto stop_requested() const noexcept
-         { return action_ == action::stop;}
-
-      template <class CompletionToken>
-      auto async_wait(CompletionToken token)
-      {
-         return timer_.async_wait(std::move(token));
-      }
-
-   private:
-      enum class status
-      { none
-      , staged
-      , written
-      };
-
-      timer_type timer_;
-      action action_;
-      request const* req_;
-      std::size_t cmds_;
-      status status_;
-   };
-
-   void remove_request(std::shared_ptr<req_info> const& info)
-   {
-      reqs_.erase(std::remove(std::begin(reqs_), std::end(reqs_), info));
-   }
-
-   using reqs_type = std::deque<std::shared_ptr<req_info>>;
-
-   template <class> friend struct redis::detail::reader_op;
-   template <class, class> friend struct redis::detail::writer_op;
-   template <class, class> friend struct redis::detail::run_op;
-   template <class, class> friend struct redis::detail::exec_op;
-   template <class, class> friend class redis::detail::read_next_op;
-   template <class, class> friend struct redis::detail::receive_op;
-   template <class> friend struct redis::detail::wait_receive_op;
-   template <class, class, class> friend struct redis::detail::run_all_op;
-
-   template <class CompletionToken>
-   auto async_wait_receive(CompletionToken token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(redis::detail::wait_receive_op<this_type>{this}, token, read_op_timer_);
-   }
-
-   void cancel_push_requests()
-   {
-      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
-         return !(ptr->is_staged() && ptr->get_request().size() == 0);
-      });
-
-      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
-         ptr->proceed();
-      });
-
-      reqs_.erase(point, std::end(reqs_));
-   }
-
-   [[nodiscard]] bool is_writing() const noexcept
-   {
-      return !write_buffer_.empty();
-   }
-
-   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_waiting_write();
-         });
-
-         std::rotate(std::rbegin(reqs_), std::rbegin(reqs_) + 1, rend);
-      }
-
-      if (is_open() && !is_writing())
-         writer_timer_.cancel();
-   }
-
-   template <class CompletionToken>
-   auto reader(CompletionToken&& token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(redis::detail::reader_op<this_type>{this}, token, writer_timer_);
-   }
-
-   template <class CompletionToken, class Logger>
-   auto writer(Logger l, CompletionToken&& token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(redis::detail::writer_op<this_type, Logger>{this, l}, token, writer_timer_);
-   }
-
-   template <class Adapter, class CompletionToken>
-   auto async_read_next(Adapter adapter, CompletionToken token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code, std::size_t)
-         >(redis::detail::read_next_op<this_type, Adapter>{*this, adapter, reqs_.front()}, token, writer_timer_);
-   }
-
-   template <class Logger, class CompletionToken>
-   auto async_run_lean(config const& cfg, Logger l, CompletionToken token)
-   {
-      runner_.set_config(cfg);
-      l.set_prefix(runner_.get_config().log_prefix);
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(redis::detail::run_op<this_type, Logger>{this, l}, token, writer_timer_);
-   }
-
-   [[nodiscard]] bool coalesce_requests()
-   {
-      // Coalesces the requests and marks them staged. After a
-      // successful write staged requests will be marked as written.
-      auto const point = std::partition_point(std::cbegin(reqs_), std::cend(reqs_), [](auto const& ri) {
-            return !ri->is_waiting_write();
-      });
-
-      std::for_each(point, std::cend(reqs_), [this](auto const& ri) {
-         // Stage the request.
-         write_buffer_ += ri->get_request().payload();
-         ri->mark_staged();
-      });
-
-      return point != std::cend(reqs_);
-   }
-
-   bool is_waiting_response() const noexcept
-   {
-      return !std::empty(reqs_) && reqs_.front()->is_written();
-   }
-
-   void close()
-   {
-      if (stream_->next_layer().is_open())
-         stream_->next_layer().close();
-   }
-
-   bool is_next_push() const noexcept
-   {
-      return !read_buffer_.empty() && (resp3::to_type(read_buffer_.front()) == resp3::type::push);
-   }
-
-   auto is_open() const noexcept { return stream_->next_layer().is_open(); }
-   auto& lowest_layer() noexcept { return stream_->lowest_layer(); }
-
-   asio::ssl::context ctx_;
-   std::unique_ptr<next_layer_type> stream_;
-
-   // 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_;
-   timer_type read_op_timer_;
-   runner_type runner_;
-
-   using dyn_buffer_type = asio::dynamic_string_buffer<char, std::char_traits<char>, std::allocator<char>>;
-
-   std::string read_buffer_;
-   dyn_buffer_type dbuf_;
-   std::string write_buffer_;
-   reqs_type reqs_;
-};
-
-} // boost::redis::detail
-
-#endif // BOOST_REDIS_CONNECTION_BASE_HPP

include/boost/redis/detail/connector.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -12,9 +12,8 @@
 #include <boost/asio/compose.hpp>
 #include <boost/asio/connect.hpp>
 #include <boost/asio/coroutine.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
 #include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/cancel_after.hpp>
 #include <string>
 #include <chrono>
 
@@ -30,65 +29,29 @@ struct connect_op {
 
    template <class Self>
    void operator()( Self& self
-                  , std::array<std::size_t, 2> const& order = {}
-                  , system::error_code const& ec1 = {}
-                  , asio::ip::tcp::endpoint const& ep= {}
-                  , system::error_code const& ec2 = {})
+                  , system::error_code const& ec = {}
+                  , asio::ip::tcp::endpoint const& ep= {})
    {
       BOOST_ASIO_CORO_REENTER (coro)
       {
-         ctor_->timer_.expires_after(ctor_->timeout_);
-
          BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token)
-            {
-               auto f = [](system::error_code const&, auto const&) { return true; };
-               return asio::async_connect(*stream, *res_, f, token);
-            },
-            [this](auto token) { return ctor_->timer_.async_wait(token);}
-         ).async_wait(
-            asio::experimental::wait_for_one(),
-            std::move(self));
+         asio::async_connect(*stream, *res_,
+            [](system::error_code const&, auto const&) { return true; },
+            asio::cancel_after(ctor_->timeout_, std::move(self)));
 
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
+         ctor_->endpoint_ = ep;
 
-         switch (order[0]) {
-            case 0: {
-               ctor_->endpoint_ = ep;
-               self.complete(ec1);
-            } break;
-            case 1:
-            {
-               if (ec2) {
-                  self.complete(ec2);
-               } else {
-                  self.complete(error::connect_timeout);
-               }
-            } break;
-
-            default: BOOST_ASSERT(false);
+         if (ec == asio::error::operation_aborted) {
+            self.complete(redis::error::connect_timeout);
+         } else {
+            self.complete(ec);
          }
       }
    }
 };
 
-template <class Executor>
 class connector {
 public:
-   using timer_type =
-      asio::basic_waitable_timer<
-         std::chrono::steady_clock,
-         asio::wait_traits<std::chrono::steady_clock>,
-         Executor>;
-
-   connector(Executor ex)
-   : timer_{ex}
-   {}
-
    void set_config(config const& cfg)
       { timeout_ = cfg.connect_timeout; }
 
@@ -102,20 +65,7 @@ public:
       return asio::async_compose
          < CompletionToken
          , void(system::error_code)
-         >(connect_op<connector, Stream>{this, &stream, &res}, token, timer_);
-   }
-
-   std::size_t cancel(operation op)
-   {
-      switch (op) {
-         case operation::connect:
-         case operation::all:
-            timer_.cancel();
-            break;
-         default: /* ignore */;
-      }
-
-      return 0;
+         >(connect_op<connector, Stream>{this, &stream, &res}, token);
    }
 
    auto const& endpoint() const noexcept { return endpoint_;}
@@ -123,7 +73,6 @@ public:
 private:
    template <class, class> friend struct connect_op;
 
-   timer_type timer_;
    std::chrono::steady_clock::duration timeout_ = std::chrono::seconds{2};
    asio::ip::tcp::endpoint endpoint_;
 };

include/boost/redis/detail/handshaker.hpp

@@ -1,124 +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 BOOST_REDIS_SSL_CONNECTOR_HPP
-#define BOOST_REDIS_SSL_CONNECTOR_HPP
-
-#include <boost/redis/detail/helper.hpp>
-#include <boost/redis/error.hpp>
-#include <boost/asio/compose.hpp>
-#include <boost/asio/connect.hpp>
-#include <boost/asio/coroutine.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
-#include <boost/asio/ssl.hpp>
-#include <string>
-#include <chrono>
-
-namespace boost::redis::detail
-{
-
-template <class Handshaker, class Stream>
-struct handshake_op {
-   Handshaker* hsher_ = nullptr;
-   Stream* stream_ = nullptr;
-   asio::coroutine coro{};
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> const& order = {}
-                  , system::error_code const& ec1 = {}
-                  , system::error_code const& ec2 = {})
-   {
-      BOOST_ASIO_CORO_REENTER (coro)
-      {
-         hsher_->timer_.expires_after(hsher_->timeout_);
-
-         BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token) { return stream_->async_handshake(asio::ssl::stream_base::client, token); },
-            [this](auto token) { return hsher_->timer_.async_wait(token);}
-         ).async_wait(
-            asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: {
-               self.complete(ec1);
-            } break;
-            case 1:
-            {
-               if (ec2) {
-                  self.complete(ec2);
-               } else {
-                  self.complete(error::ssl_handshake_timeout);
-               }
-            } break;
-
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
-template <class Executor>
-class handshaker {
-public:
-   using timer_type =
-      asio::basic_waitable_timer<
-         std::chrono::steady_clock,
-         asio::wait_traits<std::chrono::steady_clock>,
-         Executor>;
-
-   handshaker(Executor ex)
-   : timer_{ex}
-   {}
-
-   template <class Stream, class CompletionToken>
-   auto
-   async_handshake(Stream& stream, CompletionToken&& token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(handshake_op<handshaker, Stream>{this, &stream}, token, timer_);
-   }
-
-   std::size_t cancel(operation op)
-   {
-      switch (op) {
-         case operation::ssl_handshake:
-         case operation::all:
-            timer_.cancel();
-            break;
-         default: /* ignore */;
-      }
-
-      return 0;
-   }
-
-   constexpr bool is_dummy() const noexcept
-      {return false;}
-
-   void set_config(config const& cfg)
-      { timeout_ = cfg.ssl_handshake_timeout; }
-
-private:
-   template <class, class> friend struct handshake_op;
-
-   timer_type timer_;
-   std::chrono::steady_clock::duration timeout_;
-};
-
-} // boost::redis::detail
-
-#endif // BOOST_REDIS_SSL_CONNECTOR_HPP

include/boost/redis/detail/health_checker.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -7,28 +7,28 @@
 #ifndef BOOST_REDIS_HEALTH_CHECKER_HPP
 #define BOOST_REDIS_HEALTH_CHECKER_HPP
 
-// Has to included before promise.hpp to build on msvc.
 #include <boost/redis/request.hpp>
 #include <boost/redis/response.hpp>
 #include <boost/redis/operation.hpp>
-#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/adapter/any_adapter.hpp>
 #include <boost/redis/config.hpp>
+#include <boost/redis/operation.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/asio/compose.hpp>
 #include <boost/asio/consign.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/asio/post.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
 #include <memory>
 #include <chrono>
 
 namespace boost::redis::detail {
 
-template <class HealthChecker, class Connection>
+template <class HealthChecker, class Connection, class Logger>
 class ping_op {
 public:
    HealthChecker* checker_ = nullptr;
    Connection* conn_ = nullptr;
+   Logger logger_;
    asio::coroutine coro_{};
 
    template <class Self>
@@ -36,29 +36,49 @@ public:
    {
       BOOST_ASIO_CORO_REENTER (coro_) for (;;)
       {
+         if (checker_->ping_interval_ == std::chrono::seconds::zero()) {
+            logger_.trace("ping_op (1): timeout disabled.");
+            BOOST_ASIO_CORO_YIELD
+            asio::post(std::move(self));
+            self.complete({});
+            return;
+         }
+
          if (checker_->checker_has_exited_) {
+            logger_.trace("ping_op (2): checker has exited.");
             self.complete({});
             return;
          }
 
          BOOST_ASIO_CORO_YIELD
-         conn_->async_exec(checker_->req_, checker_->resp_, std::move(self));
-         BOOST_REDIS_CHECK_OP0(checker_->wait_timer_.cancel();)
+         conn_->async_exec(checker_->req_, any_adapter(checker_->resp_), std::move(self));
+         if (ec) {
+            logger_.trace("ping_op (3)", ec);
+            checker_->wait_timer_.cancel();
+            self.complete(ec);
+            return;
+         }
 
          // Wait before pinging again.
          checker_->ping_timer_.expires_after(checker_->ping_interval_);
+
          BOOST_ASIO_CORO_YIELD
          checker_->ping_timer_.async_wait(std::move(self));
-         BOOST_REDIS_CHECK_OP0(;)
+         if (ec) {
+            logger_.trace("ping_op (4)", ec);
+            self.complete(ec);
+            return;
+         }
       }
    }
 };
 
-template <class HealthChecker, class Connection>
+template <class HealthChecker, class Connection, class Logger>
 class check_timeout_op {
 public:
    HealthChecker* checker_ = nullptr;
    Connection* conn_ = nullptr;
+   Logger logger_;
    asio::coroutine coro_{};
 
    template <class Self>
@@ -66,17 +86,33 @@ public:
    {
       BOOST_ASIO_CORO_REENTER (coro_) for (;;)
       {
+         if (checker_->ping_interval_ == std::chrono::seconds::zero()) {
+            logger_.trace("check_timeout_op (1): timeout disabled.");
+            BOOST_ASIO_CORO_YIELD
+            asio::post(std::move(self));
+            self.complete({});
+            return;
+         }
+
          checker_->wait_timer_.expires_after(2 * checker_->ping_interval_);
+
          BOOST_ASIO_CORO_YIELD
          checker_->wait_timer_.async_wait(std::move(self));
-         BOOST_REDIS_CHECK_OP0(;)
+         if (ec) {
+            logger_.trace("check_timeout_op (2)", ec);
+            self.complete(ec);
+            return;
+         }
 
          if (checker_->resp_.has_error()) {
+            // TODO: Log the error.
+            logger_.trace("check_timeout_op (3): Response error.");
             self.complete({});
             return;
          }
 
          if (checker_->resp_.value().empty()) {
+            logger_.trace("check_timeout_op (4): pong timeout.");
             checker_->ping_timer_.cancel();
             conn_->cancel(operation::run);
             checker_->checker_has_exited_ = true;
@@ -91,52 +127,6 @@ public:
    }
 };
 
-template <class HealthChecker, class Connection>
-class check_health_op {
-public:
-   HealthChecker* checker_ = nullptr;
-   Connection* conn_ = nullptr;
-   asio::coroutine coro_{};
-
-   template <class Self>
-   void
-   operator()(
-         Self& self,
-         std::array<std::size_t, 2> order = {},
-         system::error_code ec1 = {},
-         system::error_code ec2 = {})
-   {
-      BOOST_ASIO_CORO_REENTER (coro_)
-      {
-         if (checker_->ping_interval_ == std::chrono::seconds::zero()) {
-            BOOST_ASIO_CORO_YIELD
-            asio::post(std::move(self));
-            self.complete({});
-            return;
-         }
-
-         BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token) { return checker_->async_ping(*conn_, token); },
-            [this](auto token) { return checker_->async_check_timeout(*conn_, token);}
-         ).async_wait(
-            asio::experimental::wait_for_one(),
-            std::move(self));
-
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
-
-         switch (order[0]) {
-            case 0: self.complete(ec1); return;
-            case 1: self.complete(ec2); return;
-            default: BOOST_ASSERT(false);
-         }
-      }
-   }
-};
-
 template <class Executor>
 class health_checker {
 private:
@@ -161,55 +151,34 @@ public:
       ping_interval_ = cfg.health_check_interval;
    }
 
-   template <
-      class Connection,
-      class CompletionToken = asio::default_completion_token_t<Executor>
-   >
-   auto async_check_health(Connection& conn, CompletionToken token = CompletionToken{})
+   void cancel()
+   {
+      ping_timer_.cancel();
+      wait_timer_.cancel();
+   }
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_ping(Connection& conn, Logger l, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(ping_op<health_checker, Connection, Logger>{this, &conn, l}, token, conn, ping_timer_);
+   }
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_check_timeout(Connection& conn, Logger l, CompletionToken token)
    {
       checker_has_exited_ = false;
       return asio::async_compose
          < CompletionToken
          , void(system::error_code)
-         >(check_health_op<health_checker, Connection>{this, &conn}, token, conn);
-   }
-
-   std::size_t cancel(operation op)
-   {
-      switch (op) {
-         case operation::health_check:
-         case operation::all:
-            ping_timer_.cancel();
-            wait_timer_.cancel();
-            break;
-         default: /* ignore */;
-      }
-
-      return 0;
+         >(check_timeout_op<health_checker, Connection, Logger>{this, &conn, l}, token, conn, wait_timer_);
    }
 
 private:
-   template <class Connection, class CompletionToken>
-   auto async_ping(Connection& conn, CompletionToken token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(ping_op<health_checker, Connection>{this, &conn}, token, conn, ping_timer_);
-   }
-
-   template <class Connection, class CompletionToken>
-   auto async_check_timeout(Connection& conn, CompletionToken token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(check_timeout_op<health_checker, Connection>{this, &conn}, token, conn, wait_timer_);
-   }
-
-   template <class, class> friend class ping_op;
-   template <class, class> friend class check_timeout_op;
-   template <class, class> friend class check_health_op;
+   template <class, class, class> friend class ping_op;
+   template <class, class, class> friend class check_timeout_op;
 
    timer_type ping_timer_;
    timer_type wait_timer_;

include/boost/redis/detail/helper.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/detail/read.hpp

@@ -1,291 +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 BOOST_REDIS_READ_HPP
-#define BOOST_REDIS_READ_HPP
-
-#include <boost/redis/resp3/type.hpp>
-#include <boost/redis/resp3/parser.hpp>
-#include <boost/redis/adapter/ignore.hpp>
-#include <boost/redis/detail/helper.hpp>
-#include <boost/asio/read.hpp>
-#include <boost/asio/compose.hpp>
-#include <boost/asio/coroutine.hpp>
-#include <boost/asio/post.hpp>
-
-#include <string_view>
-#include <limits>
-
-namespace boost::redis::detail {
-
-template <class DynamicBuffer>
-std::string_view buffer_view(DynamicBuffer buf) noexcept
-{
-   char const* start = static_cast<char const*>(buf.data(0, buf.size()).data());
-   return std::string_view{start, std::size(buf)};
-}
-
-template <class AsyncReadStream, class DynamicBuffer>
-class append_some_op {
-private:
-   AsyncReadStream& stream_;
-   DynamicBuffer buf_;
-   std::size_t size_ = 0;
-   std::size_t tmp_ = 0;
-   asio::coroutine coro_{};
-
-public:
-   append_some_op(AsyncReadStream& stream, DynamicBuffer buf, std::size_t size)
-   : stream_ {stream}
-   , buf_ {std::move(buf)}
-   , size_{size}
-   { }
-
-   template <class Self>
-   void operator()( Self& self
-                  , system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro_)
-      {
-         tmp_ = buf_.size();
-         buf_.grow(size_);
-
-         BOOST_ASIO_CORO_YIELD
-         stream_.async_read_some(buf_.data(tmp_, size_), std::move(self));
-         if (ec) {
-            self.complete(ec, 0);
-            return;
-         }
-
-         buf_.shrink(buf_.size() - tmp_ - n);
-         self.complete({}, n);
-      }
-   }
-};
-
-template <class AsyncReadStream, class DynamicBuffer, class CompletionToken>
-auto
-async_append_some(
-   AsyncReadStream& stream,
-   DynamicBuffer buffer,
-   std::size_t size,
-   CompletionToken&& token)
-{
-   return asio::async_compose
-      < CompletionToken
-      , void(system::error_code, std::size_t)
-      >(append_some_op<AsyncReadStream, DynamicBuffer> {stream, buffer, size}, token, stream);
-}
-
-template <
-   class AsyncReadStream,
-   class DynamicBuffer,
-   class ResponseAdapter>
-class parse_op {
-private:
-   AsyncReadStream& stream_;
-   DynamicBuffer buf_;
-   resp3::parser parser_;
-   ResponseAdapter adapter_;
-   bool needs_rescheduling_ = true;
-   system::error_code ec_;
-   asio::coroutine coro_{};
-
-   static std::size_t const growth = 1024;
-
-public:
-   parse_op(AsyncReadStream& stream, DynamicBuffer buf, ResponseAdapter adapter)
-   : stream_ {stream}
-   , buf_ {std::move(buf)}
-   , adapter_ {std::move(adapter)}
-   { }
-
-   template <class Self>
-   void operator()( Self& self
-                  , system::error_code ec = {}
-                  , std::size_t = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro_)
-      {
-         while (!resp3::parse(parser_, buffer_view(buf_), adapter_, ec)) {
-            needs_rescheduling_ = false;
-            BOOST_ASIO_CORO_YIELD
-            async_append_some(
-               stream_, buf_, parser_.get_suggested_buffer_growth(growth),
-               std::move(self));
-            if (ec) {
-               self.complete(ec, 0);
-               return;
-            }
-         }
-
-         ec_ = ec;
-         if (needs_rescheduling_) {
-            BOOST_ASIO_CORO_YIELD
-            asio::post(std::move(self));
-         }
-
-         self.complete(ec_, parser_.get_consumed());
-      }
-   }
-};
-
-/** \brief Reads a complete response to a command sychronously.
- *
- *  This function reads a complete response to a command or a
- *  server push synchronously. For example
- *
- *  @code
- *  int resp;
- *  std::string buffer;
- *  resp3::read(socket, dynamic_buffer(buffer), adapt(resp));
- *  @endcode
- *
- *  For a complete example see examples/intro_sync.cpp. This function
- *  is implemented in terms of one or more calls to @c
- *  asio::read_until and @c asio::read functions, and is known as a @a
- *  composed @a operation. Furthermore, the implementation may read
- *  additional bytes from the stream that lie past the end of the
- *  message being read. These additional bytes are stored in the
- *  dynamic buffer, which must be preserved for subsequent reads.
- *
- *  \param stream The stream from which to read e.g. a tcp socket.
- *  \param buf Dynamic buffer (version 2).
- *  \param adapter The response adapter.
- *  \param ec If an error occurs, it will be assigned to this paramter.
- *  \returns The number of bytes that have been consumed from the dynamic buffer.
- *
- *  \remark This function calls buf.consume() in each chunk of data
- *  after it has been passed to the adapter. Users must not consume
- *  the bytes after it returns.
- */
-template <
-     class SyncReadStream,
-     class DynamicBuffer,
-     class ResponseAdapter
-  >
-auto
-read(
-   SyncReadStream& stream,
-   DynamicBuffer buf,
-   ResponseAdapter adapter,
-   system::error_code& ec) -> std::size_t
-{
-   static std::size_t const growth = 1024;
-
-   resp3::parser parser;
-   while (!parser.done()) {
-      auto const res = parser.consume(detail::buffer_view(buf), ec);
-      if (ec)
-         return 0UL;
-
-      if (!res.has_value()) {
-         auto const size_before = buf.size();
-         buf.grow(parser.get_suggested_buffer_growth(growth));
-         auto const n =
-            stream.read_some(
-               buf.data(size_before, parser.get_suggested_buffer_growth(growth)),
-               ec);
-         if (ec)
-            return 0UL;
-
-         buf.shrink(buf.size() - size_before - n);
-         continue;
-      }
-
-      adapter(res.value(), ec);
-      if (ec)
-         return 0UL;
-   }
-
-   return parser.get_consumed();
-}
-
-/** \brief Reads a complete response to a command sychronously.
- *  
- *  Same as the error_code overload but throws on error.
- */
-template<
-   class SyncReadStream,
-   class DynamicBuffer,
-   class ResponseAdapter = adapter::ignore>
-auto
-read(
-   SyncReadStream& stream,
-   DynamicBuffer buf,
-   ResponseAdapter adapter = ResponseAdapter{})
-{
-   system::error_code ec;
-   auto const n = redis::detail::read(stream, buf, adapter, ec);
-
-   if (ec)
-       BOOST_THROW_EXCEPTION(system::system_error{ec});
-
-   return n;
-}
-
-/** \brief Reads a complete response to a Redis command asynchronously.
- *
- *  This function reads a complete response to a command or a
- *  server push asynchronously. For example
- *
- *  @code
- *  std::string buffer;
- *  std::set<std::string> resp;
- *  co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(resp));
- *  @endcode
- *
- *  For a complete example see examples/transaction.cpp. This function
- *  is implemented in terms of one or more calls to @c
- *  asio::async_read_until and @c asio::async_read functions, and is
- *  known as a @a composed @a operation.  Furthermore, the
- *  implementation may read additional bytes from the stream that lie
- *  past the end of the message being read. These additional bytes are
- *  stored in the dynamic buffer, which must be preserved for
- *  subsequent reads.
- *
- *  \param stream The stream from which to read e.g. a tcp socket.
- *  \param buffer Dynamic buffer (version 2).
- *  \param adapter The response adapter.
- *  \param token The completion token.
- *
- *  The completion handler will receive as a parameter the total
- *  number of bytes transferred from the stream and must have the
- *  following signature
- *
- *  @code
- *  void(system::error_code, std::size_t);
- *  @endcode
- *
- *  \remark This function calls buf.consume() in each chunk of data
- *  after it has been passed to the adapter. Users must not consume
- *  the bytes after it returns.
- */
-template <
-   class AsyncReadStream,
-   class DynamicBuffer,
-   class ResponseAdapter = adapter::ignore,
-   class CompletionToken = asio::default_completion_token_t<typename AsyncReadStream::executor_type>
-   >
-auto async_read(
-   AsyncReadStream& stream,
-   DynamicBuffer buffer,
-   ResponseAdapter adapter = ResponseAdapter{},
-   CompletionToken&& token =
-      asio::default_completion_token_t<typename AsyncReadStream::executor_type>{})
-{
-   return asio::async_compose
-      < CompletionToken
-      , void(system::error_code, std::size_t)
-      >(parse_op<AsyncReadStream, DynamicBuffer, ResponseAdapter> {stream, buffer, adapter},
-        token,
-        stream);
-}
-
-} // boost::redis::detail
-
-#endif // BOOST_REDIS_READ_HPP

include/boost/redis/detail/resolver.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -8,13 +8,11 @@
 #define BOOST_REDIS_RESOLVER_HPP
 
 #include <boost/redis/config.hpp>
-#include <boost/redis/detail/helper.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/asio/compose.hpp>
 #include <boost/asio/coroutine.hpp>
-#include <boost/asio/experimental/parallel_group.hpp>
 #include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/cancel_after.hpp>
 #include <string>
 #include <chrono>
 
@@ -28,51 +26,23 @@ struct resolve_op {
 
    template <class Self>
    void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , system::error_code ec1 = {}
-                  , asio::ip::tcp::resolver::results_type res = {}
-                  , system::error_code ec2 = {})
+                  , system::error_code ec = {}
+                  , asio::ip::tcp::resolver::results_type res = {})
    {
       BOOST_ASIO_CORO_REENTER (coro)
       {
-         resv_->timer_.expires_after(resv_->timeout_);
-
          BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token)
-            {
-               return resv_->resv_.async_resolve(resv_->addr_.host, resv_->addr_.port, token);
-            },
-            [this](auto token) { return resv_->timer_.async_wait(token);}
-         ).async_wait(
-            asio::experimental::wait_for_one(),
-            std::move(self));
+         resv_->resv_.async_resolve(
+            resv_->addr_.host,
+            resv_->addr_.port,
+            asio::cancel_after(resv_->timeout_, std::move(self)));
 
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
+         resv_->results_ = res;
 
-         switch (order[0]) {
-            case 0: {
-               // Resolver completed first.
-               resv_->results_ = res;
-               self.complete(ec1);
-            } break;
-
-            case 1: {
-               if (ec2) {
-                  // Timer completed first with error, perhaps a
-                  // cancellation going on.
-                  self.complete(ec2);
-               } else {
-                  // Timer completed first without an error, this is a
-                  // resolve timeout.
-                  self.complete(error::resolve_timeout);
-               }
-            } break;
-
-            default: BOOST_ASSERT(false);
+         if (ec == asio::error::operation_aborted) {
+            self.complete(error::resolve_timeout);
+         } else {
+            self.complete(ec);
          }
       }
    }
@@ -81,13 +51,7 @@ struct resolve_op {
 template <class Executor>
 class resolver {
 public:
-   using timer_type =
-      asio::basic_waitable_timer<
-         std::chrono::steady_clock,
-         asio::wait_traits<std::chrono::steady_clock>,
-         Executor>;
-
-   resolver(Executor ex) : resv_{ex} , timer_{ex} {}
+   resolver(Executor ex) : resv_{ex} {}
 
    template <class CompletionToken>
    auto async_resolve(CompletionToken&& token)
@@ -98,19 +62,8 @@ public:
          >(resolve_op<resolver>{this}, token, resv_);
    }
 
-   std::size_t cancel(operation op)
-   {
-      switch (op) {
-         case operation::resolve:
-         case operation::all:
-            resv_.cancel();
-            timer_.cancel();
-            break;
-         default: /* ignore */;
-      }
-
-      return 0;
-   }
+   void cancel()
+      { resv_.cancel(); }
 
    auto const& results() const noexcept
       { return results_;}
@@ -126,7 +79,6 @@ private:
    template <class> friend struct resolve_op;
 
    resolver_type resv_;
-   timer_type timer_;
    address addr_;
    std::chrono::steady_clock::duration timeout_;
    asio::ip::tcp::resolver::results_type results_;

include/boost/redis/detail/resp3_handshaker.hpp

@@ -0,0 +1,116 @@
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_RUNNER_HPP
+#define BOOST_REDIS_RUNNER_HPP
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/request.hpp>
+#include <boost/redis/response.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/logger.hpp>
+#include <boost/redis/operation.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/coroutine.hpp>
+//#include <boost/asio/ip/tcp.hpp>
+#include <string>
+#include <memory>
+#include <chrono>
+
+namespace boost::redis::detail
+{
+
+void push_hello(config const& cfg, request& req);
+
+// TODO: Can we avoid this whole function whose only purpose is to
+// check for an error in the hello response and complete with an error
+// so that the parallel group that starts it can exit?
+template <class Handshaker, class Connection, class Logger>
+struct hello_op {
+   Handshaker* handshaker_ = nullptr;
+   Connection* conn_ = nullptr;
+   Logger logger_;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {}, std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         handshaker_->add_hello();
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->async_exec(handshaker_->hello_req_, any_adapter(handshaker_->hello_resp_), std::move(self));
+         logger_.on_hello(ec, handshaker_->hello_resp_);
+
+         if (ec) {
+            conn_->cancel(operation::run);
+            self.complete(ec);
+            return;
+         }
+
+         if (handshaker_->has_error_in_response()) {
+            conn_->cancel(operation::run);
+            self.complete(error::resp3_hello);
+            return;
+         }
+
+         self.complete({});
+      }
+   }
+};
+
+template <class Executor>
+class resp3_handshaker {
+public:
+   void set_config(config const& cfg)
+      { cfg_ = cfg; }
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_hello(Connection& conn, Logger l, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(hello_op<resp3_handshaker, Connection, Logger>{this, &conn, l}, token, conn);
+   }
+
+private:
+   template <class, class, class> friend struct hello_op;
+
+   void add_hello()
+   {
+      hello_req_.clear();
+      if (hello_resp_.has_value())
+         hello_resp_.value().clear();
+      push_hello(cfg_, hello_req_);
+   }
+
+   bool has_error_in_response() const noexcept
+   {
+      if (!hello_resp_.has_value())
+         return true;
+
+      auto f = [](auto const& e)
+      {
+         switch (e.data_type) {
+            case resp3::type::simple_error:
+            case resp3::type::blob_error: return true;
+            default: return false;
+         }
+      };
+
+      return std::any_of(std::cbegin(hello_resp_.value()), std::cend(hello_resp_.value()), f);
+   }
+
+   request hello_req_;
+   generic_response hello_resp_;
+   config cfg_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_RUNNER_HPP

include/boost/redis/detail/runner.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -7,22 +7,22 @@
 #ifndef BOOST_REDIS_RUNNER_HPP
 #define BOOST_REDIS_RUNNER_HPP
 
-#include <boost/redis/detail/health_checker.hpp>
+#include <boost/redis/adapter/any_adapter.hpp>
 #include <boost/redis/config.hpp>
+#include <boost/redis/request.hpp>
 #include <boost/redis/response.hpp>
 #include <boost/redis/detail/helper.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/redis/logger.hpp>
 #include <boost/redis/operation.hpp>
-#include <boost/redis/detail/connector.hpp>
-#include <boost/redis/detail/resolver.hpp>
-#include <boost/redis/detail/handshaker.hpp>
 #include <boost/asio/compose.hpp>
-#include <boost/asio/connect.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/asio/experimental/parallel_group.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/steady_timer.hpp>
+#include <boost/asio/prepend.hpp>
+#include <boost/asio/ssl.hpp>
+#include <boost/asio/cancel_after.hpp>
 #include <string>
 #include <memory>
 #include <chrono>
@@ -30,6 +30,11 @@
 namespace boost::redis::detail
 {
 
+void push_hello(config const& cfg, request& req);
+
+// TODO: Can we avoid this whole function whose only purpose is to
+// check for an error in the hello response and complete with an error
+// so that the parallel group that starts it can exit?
 template <class Runner, class Connection, class Logger>
 struct hello_op {
    Runner* runner_ = nullptr;
@@ -42,16 +47,25 @@ struct hello_op {
    {
       BOOST_ASIO_CORO_REENTER (coro_)
       {
-         runner_->hello_req_.clear();
-         if (runner_->hello_resp_.has_value())
-            runner_->hello_resp_.value().clear();
          runner_->add_hello();
 
          BOOST_ASIO_CORO_YIELD
-         conn_->async_exec(runner_->hello_req_, runner_->hello_resp_, std::move(self));
+         conn_->async_exec(runner_->hello_req_, any_adapter(runner_->hello_resp_), std::move(self));
          logger_.on_hello(ec, runner_->hello_resp_);
-         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
-         self.complete(ec);
+
+         if (ec) {
+            conn_->cancel(operation::run);
+            self.complete(ec);
+            return;
+         }
+
+         if (runner_->has_error_in_response()) {
+            conn_->cancel(operation::run);
+            self.complete(error::resp3_hello);
+            return;
+         }
+
+         self.complete({});
       }
    }
 };
@@ -64,6 +78,8 @@ private:
    Logger logger_;
    asio::coroutine coro_{};
 
+   using order_t = std::array<std::size_t, 5>;
+
 public:
    runner_op(Runner* runner, Connection* conn, Logger l)
    : runner_{runner}
@@ -73,81 +89,113 @@ public:
 
    template <class Self>
    void operator()( Self& self
-                  , std::array<std::size_t, 3> order = {}
+                  , order_t order = {}
                   , system::error_code ec0 = {}
                   , system::error_code ec1 = {}
                   , system::error_code ec2 = {}
-                  , std::size_t = 0)
+                  , system::error_code ec3 = {}
+                  , system::error_code ec4 = {})
    {
-      BOOST_ASIO_CORO_REENTER (coro_)
+      BOOST_ASIO_CORO_REENTER (coro_) for (;;)
       {
          BOOST_ASIO_CORO_YIELD
-         asio::experimental::make_parallel_group(
-            [this](auto token) { return runner_->async_run_all(*conn_, logger_, token); },
-            [this](auto token) { return runner_->health_checker_.async_check_health(*conn_, token); },
-            [this](auto token) { return runner_->async_hello(*conn_, logger_, token); }
-         ).async_wait(
-            asio::experimental::wait_for_all(),
-            std::move(self));
+         conn_->resv_.async_resolve(asio::prepend(std::move(self), order_t {}));
 
-         if (is_cancelled(self)) {
-            self.complete(asio::error::operation_aborted);
-            return;
-         }
+         logger_.on_resolve(ec0, conn_->resv_.results());
 
-         if (ec0 == error::connect_timeout || ec0 == error::resolve_timeout) {
+         if (ec0) {
             self.complete(ec0);
             return;
          }
 
-         if (order[0] == 2 && !!ec2) {
-            self.complete(ec2);
+         BOOST_ASIO_CORO_YIELD
+         conn_->ctor_.async_connect(
+            conn_->next_layer().next_layer(),
+            conn_->resv_.results(),
+            asio::prepend(std::move(self), order_t {}));
+
+         logger_.on_connect(ec0, conn_->ctor_.endpoint());
+
+         if (ec0) {
+            self.complete(ec0);
             return;
          }
 
-         if (order[0] == 1 && ec1 == error::pong_timeout) {
+         if (conn_->use_ssl()) {
+            BOOST_ASIO_CORO_YIELD
+            conn_->next_layer().async_handshake(
+               asio::ssl::stream_base::client,
+               asio::prepend(
+                  asio::cancel_after(
+                     runner_->cfg_.ssl_handshake_timeout,
+                     std::move(self)
+                  ),
+                  order_t {}
+               )
+            );
+
+            logger_.on_ssl_handshake(ec0);
+
+            if (ec0) {
+               self.complete(ec0);
+               return;
+            }
+         }
+
+         conn_->reset();
+
+         // Note: Order is important here because the writer might
+         // trigger an async_write before the async_hello thereby
+         // causing an authentication problem.
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token) { return runner_->async_hello(*conn_, logger_, token); },
+            [this](auto token) { return conn_->health_checker_.async_ping(*conn_, logger_, token); },
+            [this](auto token) { return conn_->health_checker_.async_check_timeout(*conn_, logger_, token);},
+            [this](auto token) { return conn_->reader(logger_, token);},
+            [this](auto token) { return conn_->writer(logger_, token);}
+         ).async_wait(
+            asio::experimental::wait_for_one_error(),
+            std::move(self));
+
+         if (order[0] == 0 && !!ec0) {
+            self.complete(ec0);
+            return;
+         }
+
+         if (order[0] == 2 && ec2 == error::pong_timeout) {
             self.complete(ec1);
             return;
          }
 
-         self.complete(ec0);
-      }
-   }
-};
+         // The receive operation must be cancelled because channel
+         // subscription does not survive a reconnection but requires
+         // re-subscription.
+         conn_->cancel(operation::receive);
 
-template <class Runner, class Connection, class Logger>
-struct run_all_op {
-   Runner* runner_ = nullptr;
-   Connection* conn_ = nullptr;
-   Logger logger_;
-   asio::coroutine coro_{};
-
-   template <class Self>
-   void operator()(Self& self, system::error_code ec = {}, std::size_t = 0)
-   {
-      BOOST_ASIO_CORO_REENTER (coro_)
-      {
-         BOOST_ASIO_CORO_YIELD
-         runner_->resv_.async_resolve(std::move(self));
-         logger_.on_resolve(ec, runner_->resv_.results());
-         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
-
-         BOOST_ASIO_CORO_YIELD
-         runner_->ctor_.async_connect(conn_->next_layer().next_layer(), runner_->resv_.results(), std::move(self));
-         logger_.on_connect(ec, runner_->ctor_.endpoint());
-         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
-
-         if (conn_->use_ssl()) {
-            BOOST_ASIO_CORO_YIELD
-            runner_->hsher_.async_handshake(conn_->next_layer(), std::move(self));
-            logger_.on_ssl_handshake(ec);
-            BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
+         if (!conn_->will_reconnect()) {
+            conn_->cancel(operation::reconnection);
+            self.complete(ec3);
+            return;
          }
 
+         // It is safe to use the writer timer here because we are not
+         // connected.
+         conn_->writer_timer_.expires_after(conn_->cfg_.reconnect_wait_interval);
+
          BOOST_ASIO_CORO_YIELD
-         conn_->async_run_lean(runner_->cfg_, logger_, std::move(self));
-         BOOST_REDIS_CHECK_OP0(;)
-         self.complete(ec);
+         conn_->writer_timer_.async_wait(asio::prepend(std::move(self), order_t {}));
+         if (ec0) {
+            self.complete(ec0);
+            return;
+         }
+
+         if (!conn_->will_reconnect()) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         conn_->reset_stream();
       }
    }
 };
@@ -156,29 +204,12 @@ template <class Executor>
 class runner {
 public:
    runner(Executor ex, config cfg)
-   : resv_{ex}
-   , ctor_{ex}
-   , hsher_{ex}
-   , health_checker_{ex}
-   , cfg_{cfg}
+   : cfg_{cfg}
    { }
 
-   std::size_t cancel(operation op)
-   {
-      resv_.cancel(op);
-      ctor_.cancel(op);
-      hsher_.cancel(op);
-      health_checker_.cancel(op);
-      return 0U;
-   }
-
    void set_config(config const& cfg)
    {
       cfg_ = cfg;
-      resv_.set_config(cfg);
-      ctor_.set_config(cfg);
-      hsher_.set_config(cfg);
-      health_checker_.set_config(cfg);
    }
 
    template <class Connection, class Logger, class CompletionToken>
@@ -190,28 +221,11 @@ public:
          >(runner_op<runner, Connection, Logger>{this, &conn, l}, token, conn);
    }
 
-   config const& get_config() const noexcept {return cfg_;}
-
 private:
-   using resolver_type = resolver<Executor>;
-   using connector_type = connector<Executor>;
-   using handshaker_type = detail::handshaker<Executor>;
-   using health_checker_type = health_checker<Executor>;
-   using timer_type = typename connector_type::timer_type;
 
-   template <class, class, class> friend struct run_all_op;
    template <class, class, class> friend class runner_op;
    template <class, class, class> friend struct hello_op;
 
-   template <class Connection, class Logger, class CompletionToken>
-   auto async_run_all(Connection& conn, Logger l, CompletionToken token)
-   {
-      return asio::async_compose
-         < CompletionToken
-         , void(system::error_code)
-         >(run_all_op<runner, Connection, Logger>{this, &conn, l}, token, conn);
-   }
-
    template <class Connection, class Logger, class CompletionToken>
    auto async_hello(Connection& conn, Logger l, CompletionToken token)
    {
@@ -223,23 +237,29 @@ private:
 
    void add_hello()
    {
-      if (!cfg_.username.empty() && !cfg_.password.empty() && !cfg_.clientname.empty())
-         hello_req_.push("HELLO", "3", "AUTH", cfg_.username, cfg_.password, "SETNAME", cfg_.clientname);
-      else if (cfg_.username.empty() && cfg_.password.empty() && cfg_.clientname.empty())
-         hello_req_.push("HELLO", "3");
-      else if (cfg_.clientname.empty())
-         hello_req_.push("HELLO", "3", "AUTH", cfg_.username, cfg_.password);
-      else
-         hello_req_.push("HELLO", "3", "SETNAME", cfg_.clientname);
-
-      if (cfg_.database_index)
-         hello_req_.push("SELECT", cfg_.database_index.value());
+      hello_req_.clear();
+      if (hello_resp_.has_value())
+         hello_resp_.value().clear();
+      push_hello(cfg_, hello_req_);
+   }
+
+   bool has_error_in_response() const noexcept
+   {
+      if (!hello_resp_.has_value())
+         return true;
+
+      auto f = [](auto const& e)
+      {
+         switch (e.data_type) {
+            case resp3::type::simple_error:
+            case resp3::type::blob_error: return true;
+            default: return false;
+         }
+      };
+
+      return std::any_of(std::cbegin(hello_resp_.value()), std::cend(hello_resp_.value()), f);
    }
 
-   resolver_type resv_;
-   connector_type ctor_;
-   handshaker_type hsher_;
-   health_checker_type health_checker_;
    request hello_req_;
    generic_response hello_resp_;
    config cfg_;

include/boost/redis/detail/write.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/error.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -75,6 +75,15 @@ enum class error
 
    /// SSL handshake timeout
    ssl_handshake_timeout,
+
+   /// Can't receive push synchronously without blocking
+   sync_receive_push_failed,
+
+   /// Incompatible node depth.
+   incompatible_node_depth,
+
+   /// Resp3 hello command error
+   resp3_hello,
 };
 
 /** \internal

include/boost/redis/ignore.hpp

@@ -1,5 +1,5 @@
 
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/impl/connection.ipp

@@ -1,25 +1,26 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
  */
 
 #include <boost/redis/connection.hpp>
+#include <cstddef>
 
 namespace boost::redis {
 
 connection::connection(
    executor_type ex,
-   asio::ssl::context::method method,
+   asio::ssl::context ctx,
    std::size_t max_read_size)
-: impl_{ex, method, max_read_size}
+: impl_{ex, std::move(ctx), max_read_size}
 { }
 
 connection::connection(
    asio::io_context& ioc,
-   asio::ssl::context::method method,
+   asio::ssl::context ctx,
    std::size_t max_read_size)
-: impl_{ioc.get_executor(), method, max_read_size}
+: impl_{ioc.get_executor(), std::move(ctx), max_read_size}
 { }
 
 void
@@ -31,6 +32,15 @@ connection::async_run_impl(
    impl_.async_run(cfg, l, std::move(token));
 }
 
+void
+connection::async_exec_impl(
+   request const& req,
+   any_adapter&& adapter,
+   asio::any_completion_handler<void(boost::system::error_code, std::size_t)> token)
+{
+   impl_.async_exec(req, std::move(adapter), std::move(token));
+}
+
 void connection::cancel(operation op)
 {
    impl_.cancel(op);

include/boost/redis/impl/error.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -41,6 +41,10 @@ struct error_category_impl : system::error_category {
 	 case error::resolve_timeout: return "Resolve timeout.";
 	 case error::connect_timeout: return "Connect timeout.";
 	 case error::pong_timeout: return "Pong timeout.";
+	 case error::ssl_handshake_timeout: return "SSL handshake timeout.";
+	 case error::sync_receive_push_failed: return "Can't receive server push synchronously without blocking.";
+	 case error::incompatible_node_depth: return "Incompatible node depth.";
+	 case error::resp3_hello: return "RESP3 handshake error (hello command).";
 	 default: BOOST_ASSERT(false); return "Boost.Redis error.";
       }
    }

include/boost/redis/impl/ignore.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/impl/logger.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -25,7 +25,7 @@ void logger::on_resolve(system::error_code const& ec, asio::ip::tcp::resolver::r
 
    write_prefix();
 
-   std::clog << "Resolve results: ";
+   std::clog << "resolve results: ";
 
    if (ec) {
       std::clog << ec.message() << std::endl;
@@ -51,7 +51,7 @@ void logger::on_connect(system::error_code const& ec, asio::ip::tcp::endpoint co
 
    write_prefix();
 
-   std::clog << "Connected to endpoint: ";
+   std::clog << "connected to ";
 
    if (ec)
       std::clog << ec.message() << std::endl;
@@ -71,21 +71,6 @@ void logger::on_ssl_handshake(system::error_code const& ec)
    std::clog << "SSL handshake: " << ec.message() << std::endl;
 }
 
-void logger::on_connection_lost(system::error_code const& ec)
-{
-   if (level_ < level::info)
-      return;
-
-   write_prefix();
-
-   if (ec)
-      std::clog << "Connection lost: " << ec.message();
-   else
-      std::clog << "Connection lost.";
-
-   std::clog << std::endl;
-}
-
 void
 logger::on_write(
    system::error_code const& ec,
@@ -97,9 +82,24 @@ logger::on_write(
    write_prefix();
 
    if (ec)
-      std::clog << "Write: " << ec.message();
+      std::clog << "writer_op: " << ec.message();
    else
-      std::clog << "Bytes written: " << std::size(payload);
+      std::clog << "writer_op: " << std::size(payload) << " bytes written.";
+
+   std::clog << std::endl;
+}
+
+void logger::on_read(system::error_code const& ec, std::size_t n)
+{
+   if (level_ < level::info)
+      return;
+
+   write_prefix();
+
+   if (ec)
+      std::clog << "reader_op: " << ec.message();
+   else
+      std::clog << "reader_op: " << n << " bytes read.";
 
    std::clog << std::endl;
 }
@@ -115,14 +115,34 @@ logger::on_hello(
    write_prefix();
 
    if (ec) {
-      std::clog << "Hello: " << ec.message();
+      std::clog << "hello_op: " << ec.message();
       if (resp.has_error())
          std::clog << " (" << resp.error().diagnostic << ")";
    } else {
-      std::clog << "Hello: Success";
+      std::clog << "hello_op: Success";
    }
 
    std::clog << std::endl;
 }
 
+void logger::trace(std::string_view message)
+{
+   if (level_ < level::debug)
+      return;
+
+   write_prefix();
+
+   std::clog << message << std::endl;
+}
+
+void logger::trace(std::string_view op, system::error_code const& ec)
+{
+   if (level_ < level::debug)
+      return;
+
+   write_prefix();
+
+   std::clog << op << ": " << ec.message() << std::endl;
+}
+
 } // boost::redis

include/boost/redis/impl/request.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/impl/resp3_handshaker.ipp

@@ -0,0 +1,27 @@
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/detail/resp3_handshaker.hpp>
+
+namespace boost::redis::detail
+{
+
+void push_hello(config const& cfg, request& req)
+{
+   if (!cfg.username.empty() && !cfg.password.empty() && !cfg.clientname.empty())
+      req.push("HELLO", "3", "AUTH", cfg.username, cfg.password, "SETNAME", cfg.clientname);
+   else if (cfg.password.empty() && cfg.clientname.empty())
+      req.push("HELLO", "3");
+   else if (cfg.clientname.empty())
+      req.push("HELLO", "3", "AUTH", cfg.username, cfg.password);
+   else
+      req.push("HELLO", "3", "SETNAME", cfg.clientname);
+
+   if (cfg.database_index && cfg.database_index.value() != 0)
+      req.push("SELECT", cfg.database_index.value());
+}
+
+} // boost::redis::detail

include/boost/redis/impl/response.ipp

@@ -0,0 +1,48 @@
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/response.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/assert.hpp>
+
+namespace boost::redis
+{
+
+void consume_one(generic_response& r, system::error_code& ec)
+{
+   if (r.has_error())
+      return; // Nothing to consume.
+
+   if (std::empty(r.value()))
+      return; // Nothing to consume.
+
+   auto const depth = r.value().front().depth;
+
+   // To simplify we will refuse to consume any data-type that is not
+   // a root node. I think there is no use for that and it is complex
+   // since it requires updating parent nodes.
+   if (depth != 0) {
+      ec = error::incompatible_node_depth;
+      return;
+   }
+
+   auto f = [depth](auto const& e)
+      { return e.depth == depth; };
+
+   auto match = std::find_if(std::next(std::cbegin(r.value())), std::cend(r.value()), f);
+
+   r.value().erase(std::cbegin(r.value()), match);
+}
+
+void consume_one(generic_response& r)
+{
+   system::error_code ec;
+   consume_one(r, ec);
+   if (ec)
+      throw system::system_error(ec);
+}
+
+} // boost::redis::resp3

include/boost/redis/logger.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -19,6 +19,10 @@ namespace boost::redis {
  *  @ingroup high-level-api
  *
  *  The class can be passed to the connection objects to log to `std::clog`
+ *
+ *  Notice that currently this class has no stable interface. Users
+ *  that don't want any logging can disable it by contructing a logger
+ *  with logger::level::emerg to the connection.
  */
 class logger {
 public:
@@ -26,7 +30,11 @@ public:
     *  @ingroup high-level-api
     */
    enum class level
-   {  /// Emergency
+   {
+      /// Disabled
+      disabled,
+
+      /// Emergency
       emerg,
 
       /// Alert
@@ -56,7 +64,7 @@ public:
     *
     *  @param l Log level.
     */
-   logger(level l = level::info)
+   logger(level l = level::debug)
    : level_{l}
    {}
 
@@ -83,13 +91,6 @@ public:
     */
    void on_ssl_handshake(system::error_code const& ec);
 
-   /** @brief Called when the connection is lost.
-    *  @ingroup high-level-api
-    *
-    *  @param ec Error returned when the connection is lost.
-    */
-   void on_connection_lost(system::error_code const& ec);
-
    /** @brief Called when the write operation completes.
     *  @ingroup high-level-api
     *
@@ -98,6 +99,14 @@ public:
     */
    void on_write(system::error_code const& ec, std::string const& payload);
 
+   /** @brief Called when the read operation completes.
+    *  @ingroup high-level-api
+    *
+    *  @param ec Error code returned by the read operation.
+    *  @param n Number of bytes read.
+    */
+   void on_read(system::error_code const& ec, std::size_t n);
+
    /** @brief Called when the `HELLO` request completes.
     *  @ingroup high-level-api
     *
@@ -116,6 +125,9 @@ public:
       prefix_ = prefix;
    }
 
+   void trace(std::string_view message);
+   void trace(std::string_view op, system::error_code const& ec);
+
 private:
    void write_prefix();
    level level_;

include/boost/redis/operation.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/request.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -47,31 +47,31 @@ class request {
 public:
    /// Request configuration options.
    struct config {
-      /** \brief If `true` 
-       * `boost::redis::connection::async_exec` will complete with error if the
-       * connection is lost. Affects only requests that haven't been
-       * sent yet.
+      /** \brief If `true` calls to `connection::async_exec` will
+       * complete with error if the connection is lost while the
+       * request hasn't been sent yet.
        */
       bool cancel_on_connection_lost = true;
 
-      /** \brief If `true` the request will complete with
-       * boost::redis::error::not_connected if `async_exec` is called before
-       * the connection with Redis was established.
+      /** \brief If `true` `connection::async_exec` will complete with
+       * `boost::redis::error::not_connected` if the call happens
+       * before the connection with Redis was established.
        */
       bool cancel_if_not_connected = false;
 
-      /** \brief If `false` `boost::redis::connection::async_exec` will not
+      /** \brief If `false` `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 `boost::redis::connection::async_run`
-       * completed.
+       * but remained unresponded when
+       * `boost::redis::connection::async_run` completed.
        */
       bool cancel_if_unresponded = true;
 
-      /** \brief If this request has a `HELLO` command and this flag is
-       * `true`, the `boost::redis::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.
+      /** \brief If this request has a `HELLO` command and this flag
+       * is `true`, the `boost::redis::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;
    };
@@ -84,8 +84,12 @@ public:
     request(config cfg = config{true, false, true, true})
     : cfg_{cfg} {}
 
+    //// Returns the number of responses expected for this request.
+   [[nodiscard]] auto get_expected_responses() const noexcept -> std::size_t
+      { return expected_responses_;};
+
     //// Returns the number of commands contained in this request.
-   [[nodiscard]] auto size() const noexcept -> std::size_t
+   [[nodiscard]] auto get_commands() const noexcept -> std::size_t
       { return commands_;};
 
    [[nodiscard]] auto payload() const noexcept -> std::string_view
@@ -99,6 +103,7 @@ public:
    {
       payload_.clear();
       commands_ = 0;
+      expected_responses_ = 0;
       has_hello_priority_ = false;
    }
 
@@ -303,8 +308,10 @@ public:
 private:
    void check_cmd(std::string_view cmd)
    {
+      ++commands_;
+
       if (!detail::has_response(cmd))
-         ++commands_;
+         ++expected_responses_;
 
       if (cmd == "HELLO")
          has_hello_priority_ = cfg_.hello_with_priority;
@@ -313,6 +320,7 @@ private:
    config cfg_;
    std::string payload_;
    std::size_t commands_ = 0;
+   std::size_t expected_responses_ = 0;
    bool has_hello_priority_ = false;
 };
 

include/boost/redis/resp3/impl/parser.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -9,10 +9,11 @@
 #include <boost/assert.hpp>
 
 #include <charconv>
+#include <limits>
 
 namespace boost::redis::resp3 {
 
-void to_int(int_type& i, std::string_view sv, system::error_code& ec)
+void to_int(std::size_t& i, std::string_view sv, system::error_code& ec)
 {
    auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
    if (res.ec != std::errc())
@@ -21,6 +22,16 @@ void to_int(int_type& i, std::string_view sv, system::error_code& ec)
 
 parser::parser()
 {
+   reset();
+}
+
+void parser::reset()
+{
+   depth_ = 0;
+   sizes_ = {{1}};
+   bulk_length_ = (std::numeric_limits<std::size_t>::max)();
+   bulk_ = type::invalid;
+   consumed_ = 0;
    sizes_[0] = 2; // The sentinel must be more than 1.
 }
 
@@ -178,7 +189,7 @@ parser::consume_impl(
       case type::attribute:
       case type::map:
       {
-         int_type l = -1;
+         std::size_t l = -1;
          to_int(l, elem, ec);
          if (ec)
             return {};

include/boost/redis/resp3/impl/serialization.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/resp3/impl/type.ipp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/resp3/node.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -54,11 +54,16 @@ auto operator==(basic_node<String> const& a, basic_node<String> const& b)
        && a.value == b.value;
 };
 
-/** @brief A node in the response tree.
+/** @brief A node in the response tree that owns its data
  *  @ingroup high-level-api
  */
 using node = basic_node<std::string>;
 
+/** @brief A node view in the response tree
+ *  @ingroup high-level-api
+ */
+using node_view = basic_node<std::string_view>;
+
 } // boost::redis::resp3
 
 #endif // BOOST_REDIS_RESP3_NODE_HPP

include/boost/redis/resp3/parser.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -10,15 +10,12 @@
 #include <boost/redis/resp3/node.hpp>
 #include <boost/system/error_code.hpp>
 #include <array>
-#include <limits>
 #include <string_view>
 #include <cstdint>
 #include <optional>
 
 namespace boost::redis::resp3 {
 
-using int_type = std::uint64_t;
-
 class parser {
 public:
    using node_type = basic_node<std::string_view>;
@@ -31,22 +28,22 @@ private:
    // 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.
-   std::size_t depth_ = 0;
+   std::size_t depth_;
 
    // The parser supports up to 5 levels of nested structures. The
    // first element in the sizes stack is a sentinel and must be
    // different from 1.
-   std::array<std::size_t, max_embedded_depth + 1> sizes_ = {{1}};
+   std::array<std::size_t, max_embedded_depth + 1> sizes_;
 
    // Contains the length expected in the next bulk read.
-   int_type bulk_length_ = (std::numeric_limits<unsigned long>::max)();
+   std::size_t bulk_length_;
 
    // The type of the next bulk. Contains type::invalid if no bulk is
    // expected.
-   type bulk_ = type::invalid;
+   type bulk_;
 
    // The number of bytes consumed from the buffer.
-   std::size_t consumed_ = 0;
+   std::size_t consumed_;
 
    // Returns the number of bytes that have been consumed.
    auto consume_impl(type t, std::string_view elem, system::error_code& ec) -> node_type;
@@ -71,8 +68,13 @@ public:
    auto get_consumed() const noexcept -> std::size_t;
 
    auto consume(std::string_view view, system::error_code& ec) noexcept -> result;
+
+   void reset();
 };
 
+// Returns false if more data is needed. If true is returned the
+// parser is either done or an error occured, that can be checked on
+// ec.
 template <class Adapter>
 bool
 parse(

include/boost/redis/resp3/serialization.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/resp3/type.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)

include/boost/redis/response.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -9,12 +9,14 @@
 
 #include <boost/redis/resp3/node.hpp>
 #include <boost/redis/adapter/result.hpp>
+#include <boost/system.hpp>
 
 #include <vector>
 #include <string>
 #include <tuple>
 
-namespace boost::redis {
+namespace boost::redis
+{
 
 /** @brief Response with compile-time size.
  *  @ingroup high-level-api
@@ -32,6 +34,47 @@ using response = std::tuple<adapter::result<Ts>...>;
  */
 using generic_response = adapter::result<std::vector<resp3::node>>;
 
-} // boost::redis::resp3
+/** @brief Consume on response from a generic response
+ *
+ *  This function rotates the elements so that the start of the next
+ *  response becomes the new front element. For example the output of
+ *  the following code
+ *
+ * @code
+ * request req;
+ * req.push("PING", "one");
+ * req.push("PING", "two");
+ * req.push("PING", "three");
+ *
+ * generic_response resp;
+ * co_await conn->async_exec(req, resp, asio::deferred);
+ *
+ * std::cout << "PING: " << resp.value().front().value << std::endl;
+ * consume_one(resp);
+ * std::cout << "PING: " << resp.value().front().value << std::endl;
+ * consume_one(resp);
+ * std::cout << "PING: " << resp.value().front().value << std::endl;
+ * @endcode
+ *
+ * is
+ *
+ * @code
+ * PING: one
+ * PING: two
+ * PING: three
+ * @endcode
+ *
+ * Given that this function rotates elements, it won't be very
+ * efficient for responses with a large number of elements. It was
+ * introduced mainly to deal with buffers server pushes as shown in
+ * the cpp20_subscriber.cpp example. In the future queue-like
+ * responses might be introduced to consume in O(1) operations. 
+ */
+void consume_one(generic_response& r, system::error_code& ec);
+
+/// Throwing overload of `consume_one`.
+void consume_one(generic_response& r);
+
+} // boost::redis
 
 #endif // BOOST_REDIS_RESPONSE_HPP

include/boost/redis/src.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE.txt)
@@ -9,6 +9,8 @@
 #include <boost/redis/impl/request.ipp>
 #include <boost/redis/impl/ignore.ipp>
 #include <boost/redis/impl/connection.ipp>
+#include <boost/redis/impl/response.ipp>
+#include <boost/redis/impl/resp3_handshaker.ipp>
 #include <boost/redis/resp3/impl/type.ipp>
 #include <boost/redis/resp3/impl/parser.ipp>
 #include <boost/redis/resp3/impl/serialization.ipp>

include/boost/redis/usage.hpp

@@ -0,0 +1,43 @@
+/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_USAGE_HPP
+#define BOOST_REDIS_USAGE_HPP
+
+namespace boost::redis
+{
+
+/** @brief Connection usage information.
+ *  @ingroup high-level-api
+ *
+ *  @note: To simplify the implementation, the commands_sent and
+ *  bytes_sent in the struct below are computed just before writing to
+ *  the socket, which means on error they might not represent exactly
+ *  what has been received by the Redis server.
+ */
+struct usage {
+   /// Number of commands sent.
+   std::size_t commands_sent = 0;
+
+   /// Number of bytes sent.
+   std::size_t bytes_sent = 0;
+
+   /// Number of responses received.
+   std::size_t responses_received = 0;
+
+   /// Number of pushes received.
+   std::size_t pushes_received = 0;
+
+   /// Number of response-bytes received.
+   std::size_t response_bytes_received = 0;
+
+   /// Number of push-bytes received.
+   std::size_t push_bytes_received = 0;
+};
+
+} // boost::redis
+
+#endif // BOOST_REDIS_USAGE_HPP

index.html

@@ -0,0 +1,24 @@
+<html>
+
+<head>
+    <title>Boost.Redis</title>
+    <meta http-equiv="refresh" content="0; URL=./doc/html/index.html">
+</head>
+
+<body>
+    Automatic redirection failed, please go to
+    <a href="./doc/html/index.html">./doc/html/index.html</a>
+    <hr>
+    <tt>
+        Boost.Redis<br>
+        <br>
+        Copyright&nbsp;(C)&nbsp;2023&nbsp;Marcelo&nbsp;Zimbres<br>
+        <br>
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        <a href=http://www.boost.org/LICENSE_1_0.txt>http://www.boost.org/LICENSE_1_0.txt</a>) <br>
+        <br>
+    </tt>
+</body>
+
+</html>

meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "redis",
+    "name": "Redis",
+    "authors": [
+        "Marcelo Zimbres Silva"
+    ],
+    "description": "Redis async client library built on top of Boost.Asio.",
+    "category": [
+        "Concurrent",
+        "IO"
+    ],
+    "maintainers": [
+        "Marcelo Zimbres Silva <mzimbres@gmail.com>"
+    ],
+    "cxxstd": "17"
+}

test/CMakeLists.txt

@@ -0,0 +1,76 @@
+
+# Common utilities
+add_library(boost_redis_project_options INTERFACE)
+target_link_libraries(boost_redis_project_options INTERFACE boost_redis)
+if (MSVC)
+  target_compile_options(boost_redis_project_options INTERFACE /bigobj)
+  target_compile_definitions(boost_redis_project_options INTERFACE _WIN32_WINNT=0x0601)
+endif()
+
+add_library(boost_redis_src STATIC boost_redis.cpp)
+target_compile_features(boost_redis_src PRIVATE cxx_std_17)
+target_link_libraries(boost_redis_src PRIVATE boost_redis_project_options)
+
+# Test utils
+add_library(boost_redis_tests_common STATIC common.cpp)
+target_compile_features(boost_redis_tests_common PRIVATE cxx_std_17)
+target_link_libraries(boost_redis_tests_common PRIVATE boost_redis_project_options)
+
+macro(make_test TEST_NAME STANDARD)
+  set(EXE_NAME "boost_redis_${TEST_NAME}")
+  add_executable(${EXE_NAME} ${TEST_NAME}.cpp)
+  target_link_libraries(${EXE_NAME} PRIVATE
+    boost_redis_src
+    boost_redis_tests_common
+    boost_redis_project_options
+    Boost::unit_test_framework
+  )
+  target_compile_features(${EXE_NAME} PRIVATE cxx_std_${STANDARD})
+  add_test(${EXE_NAME} ${EXE_NAME})
+endmacro()
+
+make_test(test_conn_quit 17)
+# TODO: Configure a Redis server with TLS in the CI and reenable this test.
+#make_test(test_conn_tls 17)
+make_test(test_low_level 17)
+make_test(test_conn_exec_retry 17)
+make_test(test_conn_exec_error 17)
+make_test(test_request 17)
+make_test(test_run 17)
+make_test(test_low_level_sync_sans_io 17)
+make_test(test_conn_check_health 17)
+
+make_test(test_conn_exec 20)
+make_test(test_conn_push 20)
+make_test(test_conn_reconnect 20)
+make_test(test_conn_exec_cancel 20)
+make_test(test_conn_exec_cancel2 20)
+make_test(test_conn_echo_stress 20)
+make_test(test_any_adapter 17)
+make_test(test_issue_50 20)
+make_test(test_issue_181 17)
+
+# Coverage
+set(
+  COVERAGE_TRACE_COMMAND
+  lcov --capture
+  -output-file "${PROJECT_BINARY_DIR}/coverage.info"
+  --directory "${PROJECT_BINARY_DIR}"
+  --include "${PROJECT_SOURCE_DIR}/include/*"
+)
+
+set(
+  COVERAGE_HTML_COMMAND
+  genhtml --legend -f -q
+  "${PROJECT_BINARY_DIR}/coverage.info"
+  --prefix "${PROJECT_SOURCE_DIR}"
+  --output-directory "${PROJECT_BINARY_DIR}/coverage_html"
+)
+
+add_custom_target(
+  coverage
+  COMMAND ${COVERAGE_TRACE_COMMAND}
+  COMMAND ${COVERAGE_HTML_COMMAND}
+  COMMENT "Generating coverage report"
+  VERBATIM
+)

test/Jamfile

@@ -0,0 +1,65 @@
+
+import-search /boost/config/checks ;
+import config : requires ;
+import ac ;
+
+# Configure openssl if it hasn't been done yet
+using openssl ;
+
+# Use these requirements as both regular and usage requirements across all tests
+local requirements =
+        <library>/boost/redis//boost_redis
+        <define>BOOST_ASIO_NO_DEPRECATED=1
+        <define>BOOST_ASIO_DISABLE_BOOST_ARRAY=1
+        <define>BOOST_ASIO_DISABLE_BOOST_BIND=1
+        <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME=1
+        <define>BOOST_ASIO_DISABLE_BOOST_REGEX=1
+        <toolset>msvc:<cxxflags>"/bigobj"
+        <target-os>windows:<define>_WIN32_WINNT=0x0601
+        [ requires
+            cxx14_constexpr
+            cxx14_generic_lambdas
+            cxx14_initialized_lambda_captures
+            cxx14_aggregate_nsdmi
+            cxx14_return_type_deduction
+            cxx17_hdr_charconv
+            cxx17_hdr_optional
+            cxx17_hdr_string_view
+            cxx17_hdr_variant
+            cxx17_std_apply
+            cxx17_structured_bindings
+        ]
+        [ ac.check-library /openssl//ssl    : <library>/openssl//ssl/<link>shared : <build>no ]
+        [ ac.check-library /openssl//crypto : <library>/openssl//crypto/<link>shared : <build>no ]
+        <library>/boost/test//boost_unit_test_framework
+    ;
+
+
+# Helper library
+lib redis_test_common
+    :
+        boost_redis.cpp
+        common.cpp
+    : requirements $(requirements)
+    : usage-requirements $(requirements)
+;
+
+# B2 runs tests in parallel, and some tests rely on having exclusive
+# access to a Redis server, so we only run the ones that don't require a DB server.
+local tests =
+    test_low_level_sync_sans_io
+    test_low_level
+    test_request
+    test_run
+    test_any_adapter
+;
+
+# Build and run the tests
+for local test in $(tests)
+{
+    run
+        $(test).cpp
+        redis_test_common/<link>static
+    : target-name $(test)
+    ;
+}

test/cmake_b2_test/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.5...3.22)
+
+project(boost_redis_b2_test LANGUAGES CXX)
+
+find_package(Boost REQUIRED COMPONENTS headers)
+find_package(Threads REQUIRED)
+find_package(OpenSSL REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE Boost::headers Threads::Threads OpenSSL::Crypto OpenSSL::SSL)
+
+include(CTest)
+add_test(NAME main COMMAND main)

test/cmake_b2_test/main.cpp

@@ -0,0 +1,15 @@
+/* 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/redis/connection.hpp>
+#include <boost/redis/src.hpp>
+
+int main()
+{
+    boost::redis::connection conn(boost::asio::system_executor{});
+    return static_cast<int>(!conn.will_reconnect());
+}

test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.5...3.22)
+
+project(cmake_install_test LANGUAGES CXX)
+
+find_package(boost_redis REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE Boost::redis)
+
+include(CTest)
+add_test(main main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_install_test/main.cpp

@@ -0,0 +1,15 @@
+/* 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/redis/connection.hpp>
+#include <boost/redis/src.hpp>
+
+int main()
+{
+    boost::redis::connection conn(boost::asio::system_executor{});
+    return static_cast<int>(!conn.will_reconnect());
+}

test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.5...3.22)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+set(BOOST_INCLUDE_LIBRARIES redis)
+
+# Build our dependencies, so the targets Boost::xxx are defined
+add_subdirectory(../../../.. boostorg/boost)
+
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE Boost::redis)
+
+include(CTest)
+add_test(main main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_subdir_test/main.cpp

@@ -0,0 +1,15 @@
+/* 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/redis/connection.hpp>
+#include <boost/redis/src.hpp>
+
+int main()
+{
+    boost::redis::connection conn(boost::asio::system_executor{});
+    return static_cast<int>(!conn.will_reconnect());
+}

test/common.cpp

@@ -1,10 +1,9 @@
 #include "common.hpp"
 #include <iostream>
+#include <cstdlib>
 #include <boost/asio/consign.hpp>
 #include <boost/asio/co_spawn.hpp>
 
-#include <boost/test/unit_test.hpp>
-
 namespace net = boost::asio;
 
 struct run_callback {
@@ -15,7 +14,6 @@ struct run_callback {
    void operator()(boost::system::error_code const& ec) const
    {
       std::cout << "async_run: " << ec.message() << std::endl;
-      //BOOST_CHECK_EQUAL(ec, expected);
       conn->cancel(op);
    }
 };
@@ -31,6 +29,32 @@ run(
    conn->async_run(cfg, {l}, run_callback{conn, op, ec});
 }
 
+static std::string safe_getenv(const char* name, const char* default_value)
+{
+    // MSVC doesn't like getenv
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+    const char* res = std::getenv(name);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+    return res ? res : default_value;
+}
+
+std::string get_server_hostname()
+{
+   return safe_getenv("BOOST_REDIS_TEST_SERVER", "localhost");
+}
+
+boost::redis::config make_test_config()
+{
+   boost::redis::config cfg;
+   cfg.addr.host = get_server_hostname();
+   return cfg;
+}
+
 #ifdef BOOST_ASIO_HAS_CO_AWAIT
 auto start(net::awaitable<void> op) -> int
 {
@@ -50,5 +74,4 @@ auto start(net::awaitable<void> op) -> int
 
    return 1;
 }
-
 #endif // BOOST_ASIO_HAS_CO_AWAIT

test/common.hpp

@@ -15,11 +15,14 @@ auto redir(boost::system::error_code& ec)
 auto start(boost::asio::awaitable<void> op) -> int;
 #endif // BOOST_ASIO_HAS_CO_AWAIT
 
+boost::redis::config make_test_config();
+std::string get_server_hostname();
+
 void
 run(
    std::shared_ptr<boost::redis::connection> conn,
-   boost::redis::config cfg = {},
+   boost::redis::config cfg = make_test_config(),
    boost::system::error_code ec = boost::asio::error::operation_aborted,
    boost::redis::operation op = boost::redis::operation::receive,
-   boost::redis::logger::level l = boost::redis::logger::level::info);
+   boost::redis::logger::level l = boost::redis::logger::level::debug);
 

test/test_any_adapter.cpp

@@ -0,0 +1,49 @@
+/* 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/redis/ignore.hpp>
+#include <boost/redis/response.hpp>
+#include <boost/redis/adapter/any_adapter.hpp>
+#include <string>
+#define BOOST_TEST_MODULE any_adapter
+#include <boost/test/included/unit_test.hpp>
+
+using boost::redis::generic_response;
+using boost::redis::response;
+using boost::redis::ignore;
+using boost::redis::any_adapter;
+
+BOOST_AUTO_TEST_CASE(any_adapter_response_types)
+{
+   // any_adapter can be used with any supported responses
+   response<int> r1;
+   response<int, std::string> r2;
+   generic_response r3;
+
+   BOOST_CHECK_NO_THROW(any_adapter{r1});
+   BOOST_CHECK_NO_THROW(any_adapter{r2});
+   BOOST_CHECK_NO_THROW(any_adapter{r3});
+   BOOST_CHECK_NO_THROW(any_adapter{ignore});
+}
+
+BOOST_AUTO_TEST_CASE(any_adapter_copy_move)
+{
+   // any_adapter can be copied/moved
+   response<int, std::string> r;
+   any_adapter ad1 {r};
+
+   // copy constructor
+   any_adapter ad2 {ad1};
+   
+   // move constructor
+   any_adapter ad3 {std::move(ad2)};
+
+   // copy assignment
+   BOOST_CHECK_NO_THROW(ad2 = ad1);
+
+   // move assignment
+   BOOST_CHECK_NO_THROW(ad2 = std::move(ad1)); 
+}

test/test_conn_check_health.cpp

@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/connection.hpp>
+#include <boost/redis/response.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE check-health
 #include <boost/test/included/unit_test.hpp>
@@ -20,13 +21,10 @@ using boost::redis::request;
 using boost::redis::ignore;
 using boost::redis::operation;
 using boost::redis::generic_response;
-using boost::redis::logger;
-using redis::config;
+using boost::redis::consume_one;
 
 // TODO: Test cancel(health_check) 
 
-std::chrono::seconds const interval{1};
-
 struct push_callback {
    connection* conn1;
    connection* conn2;
@@ -39,9 +37,8 @@ struct push_callback {
    {
       BOOST_ASIO_CORO_REENTER (coro) for (;;)
       {
-         resp2->value().clear();
          BOOST_ASIO_CORO_YIELD
-         conn2->async_receive(*resp2, *this);
+         conn2->async_receive(*this);
          if (ec) {
             std::clog << "Exiting." << std::endl;
             return;
@@ -50,6 +47,7 @@ struct push_callback {
          BOOST_TEST(resp2->has_value());
          BOOST_TEST(!resp2->value().empty());
          std::clog << "Event> " << resp2->value().front().value << std::endl;
+         consume_one(*resp2);
 
          ++i;
 
@@ -73,14 +71,12 @@ struct push_callback {
 BOOST_AUTO_TEST_CASE(check_health)
 {
    net::io_context ioc;
-
-
    connection conn1{ioc};
 
    request req1;
    req1.push("CLIENT", "PAUSE", "10000", "ALL");
 
-   config cfg1;
+   auto cfg1 = make_test_config();
    cfg1.health_check_id = "conn1";
    cfg1.reconnect_wait_interval = std::chrono::seconds::zero();
    error_code res1;
@@ -95,7 +91,7 @@ BOOST_AUTO_TEST_CASE(check_health)
    // sending MONITOR. I will therefore open a second connection.
    connection conn2{ioc};
 
-   config cfg2;
+   auto cfg2 = make_test_config();
    cfg2.health_check_id = "conn2";
    error_code res2;
    conn2.async_run(cfg2, {}, [&](auto ec){
@@ -106,6 +102,7 @@ BOOST_AUTO_TEST_CASE(check_health)
    request req2;
    req2.push("MONITOR");
    generic_response resp2;
+   conn2.set_receive_response(resp2);
 
    conn2.async_exec(req2, ignore, [](auto ec, auto) {
       std::cout << "async_exec: " << std::endl;
@@ -113,7 +110,7 @@ BOOST_AUTO_TEST_CASE(check_health)
    });
 
    //--------------------------------
-
+   
    push_callback{&conn1, &conn2, &resp2, &req1}(); // Starts reading pushes.
 
    ioc.run();

test/test_conn_echo_stress.cpp

@@ -24,14 +24,40 @@ using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::logger;
-using boost::redis::config;
 using boost::redis::connection;
+using boost::redis::usage;
+using boost::redis::error;
+
+std::ostream& operator<<(std::ostream& os, usage const& u)
+{
+   os
+      << "Commands sent: " << u.commands_sent << "\n"
+      << "Bytes sent: " << u.bytes_sent << "\n"
+      << "Responses received: " << u.responses_received << "\n"
+      << "Pushes received: " << u.pushes_received << "\n"
+      << "Response bytes received: " << u.response_bytes_received << "\n"
+      << "Push bytes received: " << u.push_bytes_received;
+
+   return os;
+}
 
 auto push_consumer(std::shared_ptr<connection> conn, int expected) -> net::awaitable<void>
 {
    int c = 0;
-   for (;;) {
-      co_await conn->async_receive(ignore, net::use_awaitable);
+   for (error_code ec;;) {
+      conn->receive(ec);
+      if (ec == error::sync_receive_push_failed) {
+         ec = {};
+         co_await conn->async_receive(redirect_error(net::use_awaitable, ec));
+      } else if (!ec) {
+         //std::cout << "Skipping suspension." << std::endl;
+      }
+
+      if (ec) {
+         BOOST_TEST(false);
+         std::cout << "push_consumer error: " << ec.message() << std::endl;
+         co_return;
+      }
       if (++c == expected)
          break;
    }
@@ -43,37 +69,16 @@ auto
 echo_session(
    std::shared_ptr<connection> conn,
    std::shared_ptr<request> pubs,
-   std::string id,
    int n) -> net::awaitable<void>
 {
-   auto ex = co_await net::this_coro::executor;
-
-   request req;
-   response<ignore_t, std::string, ignore_t> 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); // Just to mess around.
-      req.push("PING", msg);
-      req.push("PING", "lsls"); // TODO: Change to HELLO after fixing issue 105.
-      boost::system::error_code ec;
-      co_await conn->async_exec(req, resp, redir(ec));
-
-      BOOST_REQUIRE_EQUAL(ec, boost::system::error_code{});
-      BOOST_REQUIRE_EQUAL(msg, std::get<1>(resp).value());
-      req.clear();
-      std::get<1>(resp).value().clear();
-
+   for (auto i = 0; i < n; ++i)
       co_await conn->async_exec(*pubs, ignore, net::deferred);
-   }
 }
 
-auto async_echo_stress() -> net::awaitable<void>
+auto async_echo_stress(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
-   config cfg;
+   auto cfg = make_test_config();
    cfg.health_check_interval = std::chrono::seconds::zero();
    run(conn, cfg,
        boost::asio::error::operation_aborted,
@@ -86,19 +91,20 @@ auto async_echo_stress() -> net::awaitable<void>
 
    // Number of coroutines that will send pings sharing the same
    // connection to redis.
-   int const sessions = 500;
+   int const sessions = 150;
 
    // The number of pings that will be sent by each session.
-   int const msgs = 1000;
+   int const msgs = 200;
 
    // The number of publishes that will be sent by each session with
    // each message.
-   int const n_pubs = 10;
+   int const n_pubs = 25;
 
    // This is the total number of pushes we will receive.
    int total_pushes = sessions * msgs * n_pubs + 1;
 
    auto pubs = std::make_shared<request>();
+   pubs->push("PING");
    for (int i = 0; i < n_pubs; ++i)
       pubs->push("PUBLISH", "channel", "payload");
 
@@ -107,14 +113,20 @@ auto async_echo_stress() -> net::awaitable<void>
    net::co_spawn(ex, push_consumer(conn, total_pushes), net::detached);
 
    for (int i = 0; i < sessions; ++i) 
-      net::co_spawn(ex, echo_session(conn, pubs, std::to_string(i), msgs), net::detached);
+      net::co_spawn(ex, echo_session(conn, pubs, msgs), net::detached);
 }
 
 BOOST_AUTO_TEST_CASE(echo_stress)
 {
    net::io_context ioc;
-   net::co_spawn(ioc, async_echo_stress(), net::detached);
+   auto conn = std::make_shared<connection>(ioc);
+   net::co_spawn(ioc, async_echo_stress(conn), net::detached);
    ioc.run();
+
+   std::cout
+      << "-------------------\n"
+      << conn->get_usage()
+      << std::endl;
 }
 
 #else

test/test_conn_exec.cpp

@@ -4,8 +4,11 @@
  * accompanying file LICENSE.txt)
  */
 
+#include <boost/redis/adapter/any_adapter.hpp>
 #include <boost/redis/connection.hpp>
 #include <boost/system/errc.hpp>
+#include <boost/asio/detached.hpp>
+#include <string>
 #define BOOST_TEST_MODULE conn-exec
 #include <boost/test/included/unit_test.hpp>
 #include <iostream>
@@ -17,13 +20,13 @@
 // container.
 
 namespace net = boost::asio;
+using boost::redis::config;
 using boost::redis::connection;
-using boost::redis::request;
-using boost::redis::response;
 using boost::redis::generic_response;
 using boost::redis::ignore;
 using boost::redis::operation;
-using boost::redis::config;
+using boost::redis::request;
+using boost::redis::response;
 
 // Sends three requests where one of them has a hello with a priority
 // set, which means it should be executed first.
@@ -53,7 +56,7 @@ BOOST_AUTO_TEST_CASE(hello_priority)
    conn->async_exec(req1, ignore, [&](auto ec, auto){
       // Second callback to the called.
       std::cout << "req1" << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::error_code{});
+      BOOST_TEST(!ec);
       BOOST_TEST(!seen2);
       BOOST_TEST(seen3);
       seen1 = true;
@@ -62,7 +65,7 @@ BOOST_AUTO_TEST_CASE(hello_priority)
    conn->async_exec(req2, ignore, [&](auto ec, auto){
       // Last callback to the called.
       std::cout << "req2" << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::error_code{});
+      BOOST_TEST(!ec);
       BOOST_TEST(seen1);
       BOOST_TEST(seen3);
       seen2 = true;
@@ -73,7 +76,7 @@ BOOST_AUTO_TEST_CASE(hello_priority)
    conn->async_exec(req3, ignore, [&](auto ec, auto){
       // Callback that will be called first.
       std::cout << "req3" << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::error_code{});
+      BOOST_TEST(!ec);
       BOOST_TEST(!seen1);
       BOOST_TEST(!seen2);
       seen3 = true;
@@ -122,7 +125,7 @@ BOOST_AUTO_TEST_CASE(cancel_request_if_not_connected)
 
 BOOST_AUTO_TEST_CASE(correct_database)
 {
-   config cfg;
+   auto cfg = make_test_config();
    cfg.database_index = 2;
 
    net::io_context ioc;
@@ -151,6 +154,64 @@ BOOST_AUTO_TEST_CASE(correct_database)
    auto const pos = value.find("db=");
    auto const index_str = value.substr(pos + 3, 1);
    auto const index = std::stoi(index_str);
+
+   // This check might fail if more than one client is connected to
+   // redis when the CLIENT LIST command is run. 
    BOOST_CHECK_EQUAL(cfg.database_index.value(), index);
 }
 
+BOOST_AUTO_TEST_CASE(large_number_of_concurrent_requests_issue_170)
+{
+   // See https://github.com/boostorg/redis/issues/170
+
+   std::string payload;
+   payload.resize(1024);
+   std::fill(std::begin(payload), std::end(payload), 'A');
+
+   net::io_context ioc;
+   auto conn = std::make_shared<connection>(ioc);
+
+   auto cfg = make_test_config();
+   cfg.health_check_interval = std::chrono::seconds(0);
+   conn->async_run(cfg, {}, net::detached);
+
+   int counter = 0;
+   int const repeat = 8000;
+
+   for (int i = 0; i < repeat; ++i) {
+      auto req = std::make_shared<request>();
+      req->push("PING", payload);
+      conn->async_exec(*req, ignore, [req, &counter, conn](auto ec, auto) {
+         BOOST_TEST(!ec);
+         if (++counter == repeat)
+            conn->cancel();
+      });
+   }
+
+   ioc.run();
+
+   BOOST_CHECK_EQUAL(counter, repeat);
+}
+
+BOOST_AUTO_TEST_CASE(exec_any_adapter)
+{
+   // Executing an any_adapter object works
+   request req;
+   req.push("PING", "PONG");
+   response<std::string> res;
+
+   net::io_context ioc;
+
+   auto conn = std::make_shared<connection>(ioc);
+
+   conn->async_exec(req, boost::redis::any_adapter(res), [&](auto ec, auto){
+      BOOST_TEST(!ec);
+      conn->cancel();
+   });
+
+   run(conn);
+   ioc.run();
+
+   BOOST_TEST(std::get<0>(res).value() == "PONG");
+}
+

test/test_conn_exec_cancel.cpp

@@ -29,7 +29,6 @@ using boost::redis::response;
 using boost::redis::generic_response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
-using boost::redis::config;
 using boost::redis::logger;
 using boost::redis::connection;
 using namespace std::chrono_literals;
@@ -39,8 +38,8 @@ auto implicit_cancel_of_req_written() -> net::awaitable<void>
    auto ex = co_await net::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
 
-   config cfg;
-   cfg.health_check_interval = std::chrono::seconds{0};
+   auto cfg = make_test_config();
+   cfg.health_check_interval = std::chrono::seconds::zero();
    run(conn, cfg);
 
    // See NOTE1.
@@ -106,7 +105,7 @@ BOOST_AUTO_TEST_CASE(test_cancel_of_req_written_on_run_canceled)
 
    conn->async_exec(req0, ignore, c0);
 
-   config cfg;
+   auto cfg = make_test_config();
    cfg.health_check_interval = std::chrono::seconds{5};
    run(conn);
 

test/test_conn_exec_error.cpp

@@ -25,7 +25,6 @@ using boost::redis::ignore_t;
 using boost::redis::error;
 using boost::redis::logger;
 using boost::redis::operation;
-using redis::config;
 using namespace std::chrono_literals;
 
 BOOST_AUTO_TEST_CASE(no_ignore_error)
@@ -242,6 +241,8 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
    conn->async_exec(req1, ignore, c1);
 
    generic_response gresp;
+   conn->set_receive_response(gresp);
+
    auto c3 = [&](auto ec, auto)
    {
       std::cout << "async_receive" << std::endl;
@@ -254,7 +255,7 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
       conn->cancel(operation::reconnection);
    };
 
-   conn->async_receive(gresp, c3);
+   conn->async_receive(c3);
 
    run(conn);
 

test/test_conn_exec_retry.cpp

@@ -57,12 +57,12 @@ BOOST_AUTO_TEST_CASE(request_retry_false)
 
    auto c2 = [&](auto ec, auto){
       std::cout << "c2" << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
+      BOOST_CHECK_EQUAL(ec, boost::asio::error::operation_aborted);
    };
 
    auto c1 = [&](auto ec, auto){
       std::cout << "c1" << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
+      BOOST_CHECK_EQUAL(ec, boost::asio::error::operation_aborted);
    };
 
    auto c0 = [&](auto ec, auto){
@@ -74,9 +74,14 @@ BOOST_AUTO_TEST_CASE(request_retry_false)
 
    conn->async_exec(req0, ignore, c0);
 
-   config cfg;
-   cfg.health_check_interval = 5s;
-   run(conn);
+   auto cfg = make_test_config();
+   conn->async_run(cfg, {boost::redis::logger::level::debug},
+      [&](boost::system::error_code const& ec)
+      {
+         std::cout << "async_run: " << ec.message() << std::endl;
+         conn->cancel();
+      }
+   );
 
    ioc.run();
 }
@@ -108,7 +113,7 @@ BOOST_AUTO_TEST_CASE(request_retry_true)
    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
+      // should cause the third request to not complete with error
       // since it has cancel_if_unresponded = true and cancellation
       // comes after it was written.
       conn->cancel(operation::run);
@@ -137,7 +142,7 @@ BOOST_AUTO_TEST_CASE(request_retry_true)
 
    conn->async_exec(req0, ignore, c0);
 
-   config cfg;
+   auto cfg = make_test_config();
    cfg.health_check_interval = 5s;
    conn->async_run(cfg, {}, [&](auto ec){
       std::cout << ec.message() << std::endl;

test/test_conn_push.cpp

@@ -9,7 +9,7 @@
 #include <boost/system/errc.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/co_spawn.hpp>
-#include <boost/asio/experimental/as_tuple.hpp>
+#include <boost/asio/as_tuple.hpp>
 #define BOOST_TEST_MODULE conn-push
 #include <boost/test/included/unit_test.hpp>
 #include <iostream>
@@ -21,12 +21,12 @@ namespace redis = boost::redis;
 using boost::redis::operation;
 using connection = boost::redis::connection;
 using error_code = boost::system::error_code;
-using net::experimental::as_tuple;
+using net::as_tuple;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
-using redis::config;
+using boost::system::error_code;
 using boost::redis::logger;
 using namespace std::chrono_literals;
 
@@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE(receives_push_waiting_resps)
 
    auto c3 =[](auto ec, auto...)
    {
-      BOOST_TEST(!!ec);
+      std::cout << "c3: " << ec.message() << std::endl;
    };
 
    auto c2 =[&, conn](auto ec, auto...)
@@ -66,15 +66,14 @@ BOOST_AUTO_TEST_CASE(receives_push_waiting_resps)
 
    conn->async_exec(req1, ignore, c1);
 
-   run(conn, {}, {});
+   run(conn, make_test_config(), {});
 
    bool push_received = false;
-   conn->async_receive(ignore, [&, conn](auto ec, auto){
+   conn->async_receive([&, conn](auto ec, auto){
       std::cout << "async_receive" << std::endl;
       BOOST_TEST(!ec);
-      conn->cancel(operation::run);
-      conn->cancel(operation::reconnection);
       push_received = true;
+      conn->cancel();
    });
 
    ioc.run();
@@ -87,29 +86,45 @@ BOOST_AUTO_TEST_CASE(push_received1)
    net::io_context ioc;
    auto conn = std::make_shared<connection>(ioc);
 
+   // Trick: Uses SUBSCRIBE because this command has no response or
+   // better said, its response is a server push, which is what we
+   // want to test. We send two because we want to test both
+   // async_receive and receive.
    request req;
-   //req.push("HELLO", 3);
-   req.push("SUBSCRIBE", "channel");
+   req.push("SUBSCRIBE", "channel1");
+   req.push("SUBSCRIBE", "channel2");
 
    conn->async_exec(req, ignore, [conn](auto ec, auto){
       std::cout << "async_exec" << std::endl;
       BOOST_TEST(!ec);
    });
 
-   run(conn);
+   bool push_async_received = false;
+   conn->async_receive([&, conn](auto ec, auto){
+      std::cout << "(1) async_receive" << std::endl;
 
-   bool push_received = false;
-   conn->async_receive(ignore, [&, conn](auto ec, auto){
-      std::cout << "async_receive" << std::endl;
       BOOST_TEST(!ec);
-      conn->cancel(operation::run);
-      conn->cancel(operation::reconnection);
-      push_received = true;
+      push_async_received = true;
+
+      // Receives the second push synchronously.
+      error_code ec2;
+      std::size_t res = 0;
+      res = conn->receive(ec2);
+      BOOST_TEST(!ec2);
+      BOOST_TEST(res != std::size_t(0));
+
+      // Tries to receive a third push synchronously.
+      ec2 = {};
+      res = conn->receive(ec2);
+      BOOST_CHECK_EQUAL(ec2, boost::redis::make_error_code(boost::redis::error::sync_receive_push_failed));
+
+      conn->cancel();
    });
 
+   run(conn);
    ioc.run();
 
-   BOOST_TEST(push_received);
+   BOOST_TEST(push_async_received);
 }
 
 BOOST_AUTO_TEST_CASE(push_filtered_out)
@@ -128,7 +143,7 @@ BOOST_AUTO_TEST_CASE(push_filtered_out)
       BOOST_TEST(!ec);
    });
 
-   conn->async_receive(ignore, [conn](auto ec, auto){
+   conn->async_receive([&, conn](auto ec, auto){
       BOOST_TEST(!ec);
       conn->cancel(operation::reconnection);
    });
@@ -146,12 +161,12 @@ net::awaitable<void>
 push_consumer1(std::shared_ptr<connection> conn, bool& push_received)
 {
    {
-      auto [ec, ev] = co_await conn->async_receive(ignore, as_tuple(net::use_awaitable));
+      auto [ec, ev] = co_await conn->async_receive(as_tuple(net::use_awaitable));
       BOOST_TEST(!ec);
    }
 
    {
-      auto [ec, ev] = co_await conn->async_receive(ignore, as_tuple(net::use_awaitable));
+      auto [ec, ev] = co_await conn->async_receive(as_tuple(net::use_awaitable));
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    }
 
@@ -190,8 +205,10 @@ BOOST_AUTO_TEST_CASE(test_push_adapter)
    req.push("SUBSCRIBE", "channel");
    req.push("PING");
 
-   conn->async_receive(error_tag_obj, [conn](auto ec, auto) {
-      BOOST_CHECK_EQUAL(ec, boost::redis::error::incompatible_size);
+   conn->set_receive_response(error_tag_obj);
+
+   conn->async_receive([&, conn](auto ec, auto) {
+      BOOST_CHECK_EQUAL(ec, boost::asio::experimental::error::channel_cancelled);
       conn->cancel(operation::reconnection);
    });
 
@@ -199,7 +216,10 @@ BOOST_AUTO_TEST_CASE(test_push_adapter)
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
-   run(conn);
+   auto cfg = make_test_config();
+   conn->async_run(cfg, {}, [](auto ec){
+      BOOST_CHECK_EQUAL(ec, redis::error::incompatible_size);
+   });
 
    ioc.run();
 
@@ -210,7 +230,7 @@ BOOST_AUTO_TEST_CASE(test_push_adapter)
 net::awaitable<void> push_consumer3(std::shared_ptr<connection> conn)
 {
    for (;;) {
-      co_await conn->async_receive(ignore, net::use_awaitable);
+      co_await conn->async_receive(net::use_awaitable);
    }
 }
 
@@ -237,9 +257,8 @@ BOOST_AUTO_TEST_CASE(many_subscribers)
 
    auto c11 =[&](auto ec, auto...)
    {
-      std::cout << "quit sent" << std::endl;
+      std::cout << "quit sent: " << ec.message() << std::endl;
       conn->cancel(operation::reconnection);
-      BOOST_TEST(!ec);
    };
    auto c10 =[&](auto ec, auto...)
    {
@@ -299,7 +318,7 @@ BOOST_AUTO_TEST_CASE(many_subscribers)
 
    conn->async_exec(req0, ignore,  c0);
 
-   run(conn, {}, {});
+   run(conn, make_test_config(), {});
 
    net::co_spawn(ioc.get_executor(), push_consumer3(conn), net::detached);
    ioc.run();

test/test_conn_quit.cpp

@@ -18,27 +18,8 @@ using boost::redis::operation;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
-using boost::redis::config;
 using namespace std::chrono_literals;
 
-BOOST_AUTO_TEST_CASE(test_eof_no_error)
-{
-   request req;
-   req.get_config().cancel_on_connection_lost = false;
-   req.push("QUIT");
-
-   net::io_context ioc;
-   auto conn = std::make_shared<connection>(ioc);
-
-   conn->async_exec(req, ignore, [&](auto ec, auto) {
-      BOOST_TEST(!ec);
-      conn->cancel(operation::reconnection);
-   });
-
-   run(conn);
-   ioc.run();
-}
-
 // Test if quit causes async_run to exit.
 BOOST_AUTO_TEST_CASE(test_async_run_exits)
 {
@@ -62,7 +43,7 @@ BOOST_AUTO_TEST_CASE(test_async_run_exits)
    auto c3 = [](auto ec, auto)
    {
       std::clog << "c3: " << ec.message() << std::endl;
-      BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
+      BOOST_CHECK_EQUAL(ec, boost::asio::error::operation_aborted);
    };
 
    auto c2 = [&](auto ec, auto)
@@ -83,7 +64,7 @@ BOOST_AUTO_TEST_CASE(test_async_run_exits)
 
    // The healthy checker should not be the cause of async_run
    // completing, so we disable.
-   config cfg;
+   auto cfg = make_test_config();
    cfg.health_check_interval = 0s;
    cfg.reconnect_wait_interval = 0s;
    run(conn, cfg);

test/test_conn_reconnect.cpp

@@ -19,7 +19,6 @@ using boost::system::error_code;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
-using boost::redis::config;
 using boost::redis::logger;
 using boost::redis::operation;
 using boost::redis::connection;
@@ -40,7 +39,7 @@ net::awaitable<void> test_reconnect_impl()
    int i = 0;
    for (; i < 5; ++i) {
       error_code ec1, ec2;
-      config cfg;
+      auto cfg = make_test_config();
       logger l;
       co_await conn->async_exec(req, ignore, net::redirect_error(net::use_awaitable, ec1));
       //BOOST_TEST(!ec);
@@ -76,7 +75,7 @@ auto async_test_reconnect_timeout() -> net::awaitable<void>
    req1.push("BLPOP", "any", 0);
 
    st.expires_after(std::chrono::seconds{1});
-   config cfg;
+   auto cfg = make_test_config();
    co_await (
       conn->async_exec(req1, ignore, redir(ec1)) ||
       st.async_wait(redir(ec3))
@@ -100,7 +99,7 @@ auto async_test_reconnect_timeout() -> net::awaitable<void>
 
    std::cout << "ccc" << std::endl;
 
-   BOOST_CHECK_EQUAL(ec1, boost::system::errc::errc_t::operation_canceled);
+   BOOST_CHECK_EQUAL(ec1, boost::asio::error::operation_aborted);
 }
 
 BOOST_AUTO_TEST_CASE(test_reconnect_and_idle)

test/test_conn_tls.cpp

@@ -0,0 +1,126 @@
+/* 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/ssl/host_name_verification.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/redis/connection.hpp>
+#define BOOST_TEST_MODULE conn-tls
+#include <boost/test/included/unit_test.hpp>
+#include "common.hpp"
+
+namespace net = boost::asio;
+
+using connection = boost::redis::connection;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::config;
+using boost::system::error_code;
+
+// CA certificate that signed the test server's certificate.
+// This is a self-signed CA created for testing purposes.
+// This must match tools/tls/ca.crt contents
+static constexpr const char* ca_certificate = R"%(-----BEGIN CERTIFICATE-----
+MIIFSzCCAzOgAwIBAgIUNd7VUuGK4+ylzCOrmeckg2+TqX8wDQYJKoZIhvcNAQEL
+BQAwNTETMBEGA1UECgwKUmVkaXMgVGVzdDEeMBwGA1UEAwwVQ2VydGlmaWNhdGUg
+QXV0aG9yaXR5MB4XDTI0MDMzMTE0MjUyM1oXDTM0MDMyOTE0MjUyM1owNTETMBEG
+A1UECgwKUmVkaXMgVGVzdDEeMBwGA1UEAwwVQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5AMV5V66wt+MM4+oCzH0
+xPi++j23p8AOa0o3dxNd4tm5y++gAdKfoxj7oh32ZuYHA5V+sGNEalN/b3GlKXMm
+ThdVPSwqOQduny19wrb126ZeQXCfqwgSZQ+rgzaIYpw8/GRRuLDunmsdaR2eiptp
+dbv6g6P/aIF6P9mfuekwCC9KBCV6ftqOEnzulNLVw4JjY0rKB9NZqONKVMfWpNyC
+zJLCkGmza7BOpybhloZIxGJz033yCjDvIQr9GUWsA5rU9LdUiL+F1W0pWkIel1qo
+Evo0EIl3+EOcSSzETI7NPHgnSzNau39ZShV4UBj2lw0DWeNcobeMBQ8ItmqEU6V0
+gCEqfUnt10bGIDdmV3D5FKPgvhFvEjQULnblLeLDQ6XDFf+xbGEVjvTzVkLjvyKm
+H2D+SKw2O+eDU/0+xhpAf+QsWlm6pmvKWjXI5wK1rh2yssBK2pmY3LuuZCdGrvXb
+KX4j/4S9qMr43Hmyoyz0gE5I5rplqot8TvT9O/JsgQYd9fYSvdB+HbqAlJzpBZFl
+xbVBXxl0AlDFwQtNMX5ylEQPvYVDKA1M+DTqRTgQKctTfccwvovY3YMV7m5YoODZ
+ya2YSBRfQim6VsC+QPYs7p2dk1larIoMMaTaU02oMY+qT2d/eyhWKBv5W9LuowTQ
+bWa3ZhWN8lXriPgJOQnZ6iUCAwEAAaNTMFEwHQYDVR0OBBYEFCpEPlClLrgu1zFN
+Fmas5G4ybNRJMB8GA1UdIwQYMBaAFCpEPlClLrgu1zFNFmas5G4ybNRJMA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggIBAFLl1NZHp0NT5Av4GKmsJFeI
+cJOgcIygjR4SBGDAxyPqVpZk0x1q64gJsfOe1ARyI4olQPqO08FZMeB+VBYuqR3S
+fEVQZz2FT5U7IVAEZwWHOcWkrrVpEZC6PZktYJ7Yqju6+ic93inoPrHhGNZ5XA/Y
+GSfwriWkyWm2SOk35ChFH67MbPWmve8CRAXRmrOCByXwXF87wdqVYZUvH9xDe6WU
+snFWXVHr2NA7Re8ZIGp7yJOwwW+CZagepNCPUDwnI0fWOahtOTzonIjq8bfgTZPx
+2e7lBuAr9tVMpoeyUytVOlNJDojZAtKOpfMwhAG8ydhk+78aK07VVbnSYVhv7ctU
+kkkldqP/S3lBlWo44oOxenwLc9vDQNh64py7eQTD7Qv+TjqAG0ljHIDbVqlkQsgR
+pQsu7keG9O1xASSTLZVZN2/alNewpqE/eFRfPM3mtUiTiIZvSxiQnWQMbKofAZH5
+HwhVli4RKWRWPqpof4GFNkB8XwfBE+gdlFuWtyg0oRyV3sJ6Zn7E+lUpbQX4CFx3
+97vekaFNBchNYMcP3TZ9LwxTx1xOWZ5HHrHyzASG3uz2rqwAsEmdRbmK03KfEQyQ
+YpNY718btZ1D6lLino9VMgzaPhUs79bHC64O4ncl7hRclK9qa3KLQdCG1cbIR7G0
+2XVYrfsnPHX0CsPDIy7L
+-----END CERTIFICATE-----)%";
+
+static config make_tls_config()
+{
+   config cfg;
+   cfg.use_ssl = true;
+   cfg.addr.host = get_server_hostname();
+   cfg.addr.port = "6380";
+   return cfg;
+}
+
+BOOST_AUTO_TEST_CASE(ping_internal_ssl_context)
+{
+   auto const cfg = make_tls_config();
+   std::string const in = "Kabuf";
+
+   request req;
+   req.push("PING", in);
+
+   response<std::string> resp;
+
+   net::io_context ioc;
+   connection conn{ioc};
+
+   // The custom server uses a certificate signed by a CA
+   // that is not trusted by default - skip verification.
+   conn.next_layer().set_verify_mode(net::ssl::verify_none);
+
+   conn.async_exec(req, resp, [&](error_code ec, auto) {
+      BOOST_TEST(ec == std::error_code());
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, {}, [](auto) { });
+
+   ioc.run();
+
+   BOOST_CHECK_EQUAL(in, std::get<0>(resp).value());
+}
+
+BOOST_AUTO_TEST_CASE(ping_custom_ssl_context)
+{
+   auto const cfg = make_tls_config();
+   std::string const in = "Kabuf";
+
+   request req;
+   req.push("PING", in);
+
+   response<std::string> resp;
+
+   net::io_context ioc;
+   net::ssl::context ctx{boost::asio::ssl::context::tls_client};
+
+   // Configure the SSL context to trust the CA that signed the server's certificate.
+   // The test certificate uses "redis" as its common name, regardless of the actual server's hostname
+   ctx.add_certificate_authority(net::const_buffer(ca_certificate, std::strlen(ca_certificate)));
+   ctx.set_verify_mode(net::ssl::verify_peer);
+   ctx.set_verify_callback(net::ssl::host_name_verification("redis"));
+
+   connection conn{ioc, std::move(ctx)};
+
+   conn.async_exec(req, resp, [&](auto ec, auto) {
+      BOOST_TEST(ec == std::error_code());
+      conn.cancel();
+   });
+
+   conn.async_run(cfg, {}, [](auto) { });
+
+   ioc.run();
+
+   BOOST_CHECK_EQUAL(in, std::get<0>(resp).value());
+}