Boost.Asio compatibility (#2273)

* Disable using bundled standalone Asio in boost-asio workflow

* Add BOOST_ROOT to boost-asio workflow

* Add install-boost id

* Fix Boost_ROOT casing

* Fix Boost_ROOT casing on the proper variable

* Fix http_client asio include

* Fix compilation errors

---------

Co-authored-by: Stephen Berry <stephenberry.developer@gmail.com>

Author: azais-corentin

.github/workflows/boost-asio.yml

@@ -45,6 +45,7 @@ jobs:
           echo "PATH=/usr/lib/llvm-${{ matrix.compiler.version }}/bin:$PATH" >> $GITHUB_ENV
 
       - name: Install Boost
+        id: install-boost
         uses: MarkusJx/install-boost@v2
         with:
           boost_version: ${{ matrix.boost_version }}
@@ -61,7 +62,10 @@ jobs:
             -DCMAKE_BUILD_TYPE=Debug \
             -DCMAKE_CXX_STANDARD=23 \
             -DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS" \
-            -DCMAKE_EXE_LINKER_FLAGS="$CMAKE_EXE_LINKER_FLAGS"
+            -DCMAKE_EXE_LINKER_FLAGS="$CMAKE_EXE_LINKER_FLAGS" \
+            -Dglaze_USE_BUNDLED_ASIO=OFF
+        env:
+          Boost_ROOT: ${{ steps.install-boost.outputs.BOOST_ROOT }}
 
       - name: Build
         # Only build networking tests that actually use Asio

include/glaze/ext/glaze_asio.hpp

@@ -6,12 +6,18 @@
 #if __has_include(<asio.hpp>) && !defined(GLZ_USE_BOOST_ASIO)
 #include <asio.hpp>
 #include <asio/signal_set.hpp>
+#ifdef GLZ_ENABLE_SSL
+#include <asio/ssl.hpp>
+#endif
 #elif __has_include(<boost/asio.hpp>)
 #ifndef GLZ_USING_BOOST_ASIO
 #define GLZ_USING_BOOST_ASIO
 #endif
 #include <boost/asio.hpp>
 #include <boost/asio/signal_set.hpp>
+#ifdef GLZ_ENABLE_SSL
+#include <boost/asio/ssl.hpp>
+#endif
 #else
 static_assert(false, "standalone or boost asio must be included to use glaze/ext/glaze_asio.hpp");
 #endif

include/glaze/net/http_client.hpp

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include <asio.hpp>
 #include <atomic>
 #include <chrono>
 #include <expected>
@@ -18,6 +17,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "glaze/ext/glaze_asio.hpp"
 #include "glaze/net/http_router.hpp"
 #include "glaze/util/key_transformers.hpp"
 
@@ -240,7 +240,7 @@ namespace glz
          bool expected = false;
          if (should_stop.compare_exchange_strong(expected, true)) {
             if (socket && socket->is_open()) {
-               std::error_code ec;
+               asio::error_code ec;
                // This cancels pending async operations on the socket, triggering their handlers
                // with asio::error::operation_aborted.
                socket->cancel(ec);
@@ -813,7 +813,7 @@ namespace glz
          asio::async_read_until(
             *connection->socket, *connection->buffer, "\r\n",
             [this, connection, on_data = std::move(on_data), on_error = std::move(on_error),
-             on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t bytes_transferred) mutable {
+             on_disconnect = std::move(on_disconnect)](asio::error_code ec, std::size_t bytes_transferred) mutable {
                if (ec || connection->should_stop) {
                   if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop)
                      on_error(ec);
@@ -881,7 +881,7 @@ namespace glz
             *connection->socket, *connection->buffer,
             asio::transfer_exactly(total_to_read - connection->buffer->size()),
             [this, connection, chunk_size, on_data = std::move(on_data), on_error = std::move(on_error),
-             on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t) mutable {
+             on_disconnect = std::move(on_disconnect)](asio::error_code ec, std::size_t) mutable {
                if (ec || connection->should_stop) {
                   if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop)
                      on_error(ec);
@@ -931,7 +931,7 @@ namespace glz
          // Use async_read with transfer_at_least(1) - may read more data for efficiency
          asio::async_read(
             *connection->socket, *connection->buffer, asio::transfer_at_least(1),
-            [this, connection, on_data, on_error, on_disconnect](std::error_code ec,
+            [this, connection, on_data, on_error, on_disconnect](asio::error_code ec,
                                                                  std::size_t /*bytes_transferred*/) {
                if (ec || connection->should_stop) {
                   if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop) {
@@ -966,7 +966,7 @@ namespace glz
          constexpr size_t read_size = 8192;
          connection->socket->async_read_some(
             connection->buffer->prepare(read_size),
-            [this, connection, on_data, on_error, on_disconnect](std::error_code ec, std::size_t bytes_transferred) {
+            [this, connection, on_data, on_error, on_disconnect](asio::error_code ec, std::size_t bytes_transferred) {
                if (ec || connection->should_stop) {
                   if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop) {
                      on_error(ec);
@@ -1033,11 +1033,11 @@ namespace glz
 
             // Read response headers synchronously
             asio::streambuf response_buffer;
-            std::error_code ec;
+            asio::error_code ec;
             size_t header_bytes = asio::read_until(*socket, response_buffer, "\r\n\r\n", ec);
             if (ec) {
                socket->close();
-               return std::unexpected(ec);
+               return std::unexpected<std::error_code>(ec);
             }
 
             // Create a zero-copy view of the header data
@@ -1096,7 +1096,7 @@ namespace glz
             size_t body_in_buffer = response_buffer.size();
             if (content_length > body_in_buffer) {
                size_t remaining_to_read = content_length - body_in_buffer;
-               std::error_code read_ec;
+               asio::error_code read_ec;
                asio::read(*socket, response_buffer, asio::transfer_exactly(remaining_to_read), read_ec);
                if (read_ec) {
                   socket->close(); // Don't reuse a failed connection
@@ -1304,7 +1304,7 @@ namespace glz
             *socket, *buffer, asio::transfer_exactly(remaining_to_read),
             [this, socket, buffer, url, status_code = parsed_status->status_code,
              response_headers = std::move(response_headers),
-             handler = std::forward<CompletionHandler>(handler)](std::error_code ec, std::size_t) mutable {
+             handler = std::forward<CompletionHandler>(handler)](asio::error_code ec, std::size_t) mutable {
                // EOF is expected if the server closes the connection.
                if (ec && ec != asio::error::eof) {
                   handler(std::unexpected(ec));

include/glaze/net/http_server.hpp

@@ -29,11 +29,6 @@
 #include "glaze/net/websocket_connection.hpp"
 #include "glaze/util/key_transformers.hpp"
 
-// Conditionally include SSL headers only when needed
-#ifdef GLZ_ENABLE_SSL
-#include <asio/ssl.hpp>
-#endif
-
 // To deconflict Windows.h
 #ifdef DELETE
 #undef DELETE
@@ -1513,10 +1508,10 @@ namespace glz
          }
 
          conn->idle_timer->expires_after(std::chrono::seconds(conn_config_.keep_alive_timeout));
-         conn->idle_timer->async_wait([conn](std::error_code ec) {
+         conn->idle_timer->async_wait([conn](asio::error_code ec) {
             if (!ec) {
                // Timer expired - close the connection
-               std::error_code close_ec;
+               asio::error_code close_ec;
                conn->socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, close_ec);
                conn->socket->lowest_layer().close(close_ec);
             }
@@ -2016,15 +2011,15 @@ namespace glz
          auto response_buffer = std::make_shared<std::string>(std::move(response_str));
 
          asio::async_write(*conn->socket, asio::buffer(*response_buffer),
-                           [this, conn, response_buffer](std::error_code ec, std::size_t /*bytes_transferred*/) {
+                           [this, conn, response_buffer](asio::error_code ec, std::size_t /*bytes_transferred*/) {
                               if (ec) {
                                  // Write error - connection is dead
                                  return;
                               }
 
                               if (conn->should_close) {
                                  // Close the connection gracefully
-                                 std::error_code close_ec;
+                                 asio::error_code close_ec;
                                  conn->socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, close_ec);
                                  conn->socket->lowest_layer().close(close_ec);
                               }

include/glaze/net/websocket_client.hpp

@@ -8,10 +8,6 @@
 #include "glaze/net/http_client.hpp"
 #include "glaze/net/websocket_connection.hpp"
 
-#ifdef GLZ_ENABLE_SSL
-#include <asio/ssl.hpp>
-#endif
-
 namespace glz
 {
    struct websocket_client

include/glaze/net/websocket_connection.hpp

@@ -35,10 +35,6 @@
 #include "glaze/net/http_router.hpp"
 #include "glaze/util/parse.hpp"
 
-#ifdef GLZ_ENABLE_SSL
-#include <asio/ssl.hpp>
-#endif
-
 namespace glz
 {
    // WebSocket opcode constants

tests/networking_tests/http_client_test/http_client_test.cpp

@@ -136,7 +136,8 @@ class working_test_server
       // Set up custom error handler to suppress expected shutdown errors
       server_.on_error([this](std::error_code ec, std::source_location loc) {
          // Only log unexpected errors, not normal shutdown errors
-         if (running_ && ec != asio::error::eof && ec != asio::error::operation_aborted) {
+         if (running_ && ec != make_error_code(asio::error::eof) &&
+             ec != make_error_code(asio::error::operation_aborted)) {
             std::fprintf(stderr, "Server error at %s:%d: %s\n", loc.file_name(), static_cast<int>(loc.line()),
                          ec.message().c_str());
          }
@@ -260,7 +261,7 @@ class working_test_server
          asio::ip::tcp::socket socket(io);
          asio::ip::tcp::endpoint endpoint(asio::ip::make_address("127.0.0.1"), port_);
 
-         std::error_code ec;
+         asio::error_code ec;
          socket.connect(endpoint, ec);
          if (!ec) {
             socket.close();
@@ -408,7 +409,7 @@ class simple_test_client
             }
 
             // Read body
-            std::error_code ec;
+            asio::error_code ec;
             asio::read(socket, response_buffer, asio::transfer_all(), ec);
 
             std::string response_body{std::istreambuf_iterator<char>(&response_buffer),
@@ -830,7 +831,7 @@ suite glz_http_client_tests = [] {
          received_data.append(data);
       };
       auto on_error = [&](std::error_code ec) {
-         if (ec && ec != asio::error::eof && ec != asio::error::operation_aborted) {
+         if (ec && ec != make_error_code(asio::error::eof) && ec != make_error_code(asio::error::operation_aborted)) {
             error_count++;
          }
       };
@@ -886,7 +887,7 @@ suite glz_http_client_tests = [] {
          data_chunks_received++;
       };
       auto on_error = [&](std::error_code ec) {
-         if (ec && ec != asio::error::eof && ec != asio::error::operation_aborted) {
+         if (ec && ec != make_error_code(asio::error::eof) && ec != make_error_code(asio::error::operation_aborted)) {
             error_count++;
          }
       };

tests/networking_tests/http_server_api_tests/http_server_api_tests.cpp

@@ -18,6 +18,14 @@
 #include "glaze/net/http_server.hpp"
 #include "ut/ut.hpp"
 
+#if defined(GLZ_USING_BOOST_ASIO)
+namespace asio
+{
+   using namespace boost::asio;
+   using error_code = boost::system::error_code;
+}
+#endif
+
 using namespace ut;
 
 // Test data structures
@@ -1073,7 +1081,7 @@ struct raw_http_client
 
    void close()
    {
-      std::error_code ec;
+      asio::error_code ec;
       socket_.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
       socket_.close(ec);
    }
@@ -1254,7 +1262,8 @@ struct keepalive_test_server
    void setup_routes()
    {
       server_.on_error([this](std::error_code ec, std::source_location) {
-         if (running_ && ec != asio::error::eof && ec != asio::error::operation_aborted) {
+         if (running_ && ec != make_error_code(asio::error::eof) &&
+             ec != make_error_code(asio::error::operation_aborted)) {
             // Suppress expected errors during tests
          }
       });

tests/networking_tests/http_server_post_test/http_server_post_test.cpp

@@ -6,10 +6,16 @@
 #include <thread>
 #include <ut/ut.hpp>
 
-#include "asio.hpp"
-#include "asio/io_context.hpp"
 #include "glaze/net/http_server.hpp"
 
+#if defined(GLZ_USING_BOOST_ASIO)
+namespace asio
+{
+   using namespace boost::asio;
+   using error_code = boost::system::error_code;
+}
+#endif
+
 namespace
 {
    using namespace ut;
@@ -38,7 +44,7 @@ namespace
             asio::io_context io_ctx;
             asio::ip::tcp::socket sock(io_ctx);
             asio::ip::tcp::endpoint endpoint(asio::ip::make_address(test_host), uint16_t(port));
-            std::error_code ec;
+            asio::error_code ec;
             sock.connect(endpoint, ec);
             if (ec != asio::error::connection_refused) {
                return;
@@ -80,7 +86,7 @@ namespace
    {
       std::string resp;
       std::array<char, 4096> buf{};
-      std::error_code ec;
+      asio::error_code ec;
       for (;;) {
          std::size_t n = socket.read_some(asio::buffer(buf), ec);
          if (n == 0 || ec) break;
@@ -96,7 +102,7 @@ namespace
       asio::io_context io_ctx;
       asio::ip::tcp::socket socket(io_ctx);
       asio::ip::tcp::endpoint endpoint(asio::ip::make_address(test_host), uint16_t(test_port));
-      std::error_code ec;
+      asio::error_code ec;
       socket.connect(endpoint, ec);
       if (ec) {
          return "";
@@ -117,7 +123,7 @@ namespace
       asio::io_context io_ctx;
       asio::ip::tcp::socket socket(io_ctx);
       asio::ip::tcp::endpoint endpoint(asio::ip::make_address(test_host), uint16_t(test_port));
-      std::error_code ec;
+      asio::error_code ec;
       socket.connect(endpoint, ec);
       if (ec) {
          return "";

tests/networking_tests/https_test/https_test.cpp

@@ -10,8 +10,6 @@
 #include <memory>
 #include <thread>
 
-#include "asio/io_context.hpp"
-
 #ifndef GLZ_ENABLE_SSL
 #define GLZ_ENABLE_SSL
 #endif
@@ -35,7 +33,13 @@
 #undef DELETE
 #endif
 
-#include <asio.hpp>
+#if defined(GLZ_USING_BOOST_ASIO)
+namespace asio
+{
+   using namespace boost::asio;
+   using error_code = boost::system::error_code;
+}
+#endif
 
 using namespace ut;
 
@@ -308,7 +312,7 @@ struct TestUser
 };
 
 // Helper function to check if an error should be suppressed
-bool should_suppress_error(const std::error_code& ec)
+bool should_suppress_error(const asio::error_code& ec)
 {
    // Common errors that are expected during normal operation
    if (ec == asio::error::eof) return true; // Client disconnected normally
@@ -686,7 +690,7 @@ suite server_lifecycle_external_context_tests = [] {
          asio::ip::tcp::socket socket(client_io);
          asio::ip::tcp::endpoint endpoint(asio::ip::make_address("127.0.0.1"), 8443);
 
-         std::error_code ec;
+         asio::error_code ec;
          socket.connect(endpoint, ec);
          connection_successful = !ec;
          if (!ec) {
@@ -713,7 +717,7 @@ suite server_lifecycle_external_context_tests = [] {
          asio::ip::tcp::socket socket(client_io);
          asio::ip::tcp::endpoint endpoint(asio::ip::make_address("127.0.0.1"), 8443);
 
-         std::error_code ec;
+         asio::error_code ec;
          socket.connect(endpoint, ec);
          connection_refused = (ec == asio::error::connection_refused);
          if (!ec) {