Início / coding / Perguntas / 79556254
Accepted
user2366975
Asked: 2025-04-05 05:10:03 +0800 CST

exemplo básico com boost beast e coroutines como co_await uma resposta

  • 772

Finalmente eu fiz o boost e o beast compilarem, essa é minha primeira tentativa e eu não tenho a mínima ideia sobre asio. Não funciona, e eu não sei por onde começar a procurar. A depuração mostra que o código nem chega às coroutines task_main_GETor .do_session

Como base, peguei o exemplo aqui: beast pode ser usado com a palavra-chave co_await do C++20?

Como @sehe sugeriu desta vez ( da última vez ), não tentei usar nenhuma corrotina personalizada, mas acho que não sei como usar o asio.

Também estou pensando em como fazer co_spawncom o executor. Olhando a assinatura da função, pensei que ele compilaria, mas só consegui fazê-lo executar passando o io_contextque acredito não ser recomendado.

Para ser honesto, e isso é offtopic, ainda não entendi o ponto da run()função de bloqueio. O que eu quero é um cliente http assíncrono com corrotinas, para que eu possa co_awaitresponder no meu aplicativo. Mas como, se ele está bloqueando? Eu basicamente não me importo como o cliente http é implementado internamente, quase parece que o "asio é assíncrono" é enganoso porque isso parece se referir aos internos, mas eu só me importo de fora para que eu possa encadeá-lo bem na lógica do meu aplicativo sem retornos de chamada. No cliente, eu poderia até usar uma biblioteca de bloqueio e jogá-la em alguns threads, não importa para o desempenho, ao contrário de um servidor. Mas sim, eu sei que ele é capaz, e eu tenho que aprender mais sobre isso.

#include "openssl/conf.h"

#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio/co_spawn.hpp>  // added
#include <boost/asio/awaitable.hpp>  // added
#include <boost/asio/experimental/promise.hpp> // added
#include <boost/asio/experimental/use_promise.hpp> // added
#include <boost/asio/as_tuple.hpp> // added
#include <boost/asio/detached.hpp> // added
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>

namespace this_coro = boost::asio::this_coro; // added

#include <boost/certify/extensions.hpp>   // added
#include <boost/certify/https_verification.hpp>   // added

#include <syncstream>  // added

namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace net = boost::asio;            // from <boost/asio.hpp>
namespace ssl = boost::asio::ssl;       // from <boost/asio/ssl.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>
using boost::asio::use_awaitable; // added

//------------------------------------------------------------------------------

#define use_void
#ifdef use_void
using T = void;
#else
using T = std::string;
#endif

// Performs an HTTP GET and prints the response
boost::asio::awaitable<T>
do_session(
    std::string host,
    std::string port,
    std::string target,
    ssl::context& ctx)
{

    beast::error_code ec;

    auto ex = co_await net::this_coro::executor;

    // These objects perform our I/O
    tcp::resolver resolver(ex);
    beast::ssl_stream<beast::tcp_stream> stream(ex, ctx);

    // Set SNI Hostname (many hosts need this to handshake successfully)
    if(! SSL_set_tlsext_host_name(stream.native_handle(), host.c_str()))
    {
        ec.assign(static_cast<int>(::ERR_get_error()), net::error::get_ssl_category());
        std::cerr << ec.message() << "\n";
        co_return;
    }

    try{    
        // Look up the domain name
        auto const results = co_await resolver.async_resolve(host, port, use_awaitable);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Make the connection on the IP address we get from a lookup
        co_await beast::get_lowest_layer(stream).async_connect(results, use_awaitable);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Perform the SSL handshake
        co_await stream.async_handshake(ssl::stream_base::client, use_awaitable);

        // Set up an HTTP GET request message
        http::request<http::string_body> req{http::verb::get, target, 11};
        req.set(http::field::host, host);
        req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Send the HTTP request to the remote host
        co_await http::async_write(stream, req, use_awaitable);

        // This buffer is used for reading and must be persisted
        beast::flat_buffer b;

        // Declare a container to hold the response
        http::response<http::dynamic_body> res;

        // Receive the HTTP response
        auto [ec, bytes] =
            co_await http::async_read(stream, b, res, boost::asio::as_tuple(use_awaitable));

        // Write the message to standard out
        std::cout << res << std::endl;

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        if(ec == net::error::eof)
        {
            // eof is to be expected for some services
            if(ec != net::error::eof)
                throw beast::system_error(ec);
        }
        else
        {
            std::cout << res << std::endl;

            // Gracefully close the stream
            co_await stream.async_shutdown(use_awaitable);
        }

    }
    catch(beast::system_error const& se)
    {
        //std::cerr << "Handled: " << se.code().message() << "\n";
        throw; // handled at the spawn site instead
    }

    // If we get here then the connection is closed gracefully
}

//------------------------------------------------------------------------------


boost::asio::awaitable<T> task_main_GET(net::io_context &ioc)
{
    auto const host = "https://microsoftedge.github.io/Demos/json-dummy-data/64KB.json";
    auto const port = "443";
    auto const target = "/";

    std::osyncstream(std::cout) << "GET " << host << ":" << port << target << std::endl;
    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::tlsv12_client};

    // https://stackoverflow.com/a/61429566/2366975
    ctx.set_verify_mode(ssl::context::verify_peer );
    boost::certify::enable_native_https_server_verification(ctx);


    auto ex = this_coro::executor;
    auto task = boost::asio::co_spawn(
        //ex,
        ioc,
        [&]() mutable -> boost::asio::awaitable<std::string>
        {
            co_await do_session(host, port, target, ctx);
        },
        use_awaitable
    );


#ifdef use_void
    co_return;
#else
    std::string responseText = co_await task;
    std::osyncstream(std::cout) << "response:\n" << responseText << std::endl;
    co_return responseText ;
#endif
}

int main()
{
    // The io_context is required for all I/O
    net::io_context ioc;

    // https://stackoverflow.com/questions/79177275/how-can-co-spawn-be-used-with-co-await
    auto task = boost::asio::co_spawn(ioc, task_main_GET(ioc), use_awaitable);

    // Run the I/O service. The call will return when the get operation is complete.
    ioc.run();

    return EXIT_SUCCESS;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.5)

project(boost_beast_example LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Fix compiler error C1128
# https://learn.microsoft.com/en-us/cpp/error-messages/compiler-errors-1/fatal-error-c1128?view=msvc-170
if (MSVC)
    add_compile_options(/bigobj)
else ()
    add_compile_options(-Wa,-mbig-obj)   # not tested
endif ()

# OPENSSL =======================================================
# https://cmake.org/cmake/help/v3.31/module/FindOpenSSL.html
set(OPENSSL_ROOT_DIR "C:/OpenSSL-Win64")
set(OPENSSL_INCLUDE_DIR "C:/OpenSSL-Win64/include")
#find_package(OpenSSL REQUIRED PATHS "C:/OpenSSL-Win64/")
find_package(OpenSSL REQUIRED)
link_directories("C:/OpenSSL-Win64/")
include_directories(${OPENSSL_INCLUDE_DIR})
message("OPENSSL_FOUND: " ${OPENSSL_FOUND})
message("OPENSSL_INCLUDE_DIR: " ${OPENSSL_INCLUDE_DIR})
message("OPENSSL_CRYPTO_LIBRARY: " ${OPENSSL_CRYPTO_LIBRARY})
message("OPENSSL_SSL_LIBRARY: " ${OPENSSL_SSL_LIBRARY})

# BOOST =========================================================
# https://cmake.org/cmake/help/v3.31/module/FindBoost.html
set(Boost_DEBUG 1)
SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "G:/SoftwareDev/libs/boost")
SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "G:/SoftwareDev/libs/boost/bin/x64/lib/cmake")
find_package(Boost REQUIRED context system coroutine regex PATHS "G:/SoftwareDev/libs/boost/bin/x64/lib/cmake")
include_directories("G:/SoftwareDev/libs/boost/libs/beast")
include_directories(${Boost_INCLUDE_DIRS})
message("Boost_FOUND: " ${Boost_FOUND})
message("Boost_INCLUDE_DIRS: " ${Boost_INCLUDE_DIRS})
message("Boost_LIBRARY_DIRS: " ${Boost_LIBRARY_DIRS})
message("Boost_LIBRARIES: " ${Boost_LIBRARIES})
message("Boost_CONTEXT_LIBRARY: " ${Boost_CONTEXT_LIBRARY})
message("Boost_SYSTEM_LIBRARY: " ${Boost_SYSTEM_LIBRARY})

find_package(Threads REQUIRED)

add_executable(${PROJECT_NAME} main.cpp)

# CERTIFY FOR BEAST==============================================
include_directories(libs/certify/include)
if(MSVC)
    target_link_libraries(${PROJECT_NAME} Crypt32.lib)
endif()
if(APPLE)
    target_link_libraries(${PROJECT_NAME} INTERFACE "-framework CoreFoundation" "-framework Security")
    set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-Wl,-F/Library/Frameworks")
endif()


target_link_libraries(${PROJECT_NAME}  OpenSSL::Crypto OpenSSL::SSL)
# How to link boost libraries
# https://stackoverflow.com/a/43885372/2366975
target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} Threads::Threads)
c++

1 respostas

  1. Best Answer

    Houve apenas alguns erros de coro-iniciante:

    • faltando co_awaita this_coro::executorpalavra-chave transform
    • faltando std::moveno taskesperado emco_await std::move(task)

    Acho que foi basicamente isso. Então, removi a io_context&referência desnecessária e cheguei à seguinte listagem limpa. Entre as mudanças que fiz está a substituição use_awaitablepelo mais eficiente asio::deferred-- que é o token de conclusão padrão no boost recente.

    #include <boost/asio.hpp>
#include <boost/beast.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/certify/extensions.hpp>         // added
#include <boost/certify/https_verification.hpp> // added
#include <iostream>
#include <syncstream> // added

namespace asio      = boost::asio;
namespace this_coro = asio::this_coro; // added
namespace beast     = boost::beast;    // from <boost/beast.hpp>
namespace http      = beast::http;     // from <boost/beast/http.hpp>
namespace ssl       = asio::ssl;       // from <boost/asio/ssl.hpp>
using asio::ip::tcp;                   // from <boost/asio/ip/tcp.hpp>
using beast::error_code;               // from <boost/beast/core.hpp>
using namespace std::chrono_literals;

//------------------------------------------------------------------------------

using SessionResult = void;

// Performs an HTTP GET and prints the response
asio::awaitable<SessionResult> do_session( //
    std::string host, std::string port, std::string target, ssl::context& ctx) {

    auto ex = co_await this_coro::executor;

    // These objects perform our I/O
    tcp::resolver resolver(ex);
    beast::ssl_stream<beast::tcp_stream> stream(ex, ctx);

    // Set SNI Hostname (many hosts need this to handshake successfully)
    if (!::SSL_set_tlsext_host_name(stream.native_handle(), host.c_str())) {
        std::cerr << beast::error_code(static_cast<asio::error::ssl_errors>(::ERR_get_error())).message()
                  << "\n";
        co_return;
    }

    try {
        // Look up the domain name
        auto const results = co_await resolver.async_resolve(host, port);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(30s);

        // Make the connection on the IP address we get from a lookup
        co_await beast::get_lowest_layer(stream).async_connect(results);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(30s);

        // Perform the SSL handshake
        co_await stream.async_handshake(ssl::stream_base::client);

        // Set up an HTTP GET request message
        http::request<http::string_body> req{http::verb::get, target, 11};
        req.set(http::field::host, host);
        req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(30s);

        // Send the HTTP request to the remote host
        co_await http::async_write(stream, req);

        // This buffer is used for reading and must be persisted
        beast::flat_buffer b;

        // Declare a container to hold the response
        http::response<http::dynamic_body> res;

        // Receive the HTTP response
        auto [ec, bytes] =
            co_await http::async_read(stream, b, res, asio::as_tuple(asio::deferred));

        // Write the message to standard out
        std::cout << res << std::endl;

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(30s);

        if(ec == asio::error::eof)
        {
            // eof is to be expected for some services
            if(ec != asio::error::eof)
                throw beast::system_error(ec);
        }
        else
        {
            std::cout << res << std::endl;

            // Gracefully close the stream
            co_await stream.async_shutdown();
        }

    } catch (beast::system_error const& se) {
        //std::cerr << "Handled: " << se.code().message() << "\n";
        throw; // handled at the spawn site instead
    }

    // If we get here then the connection is closed gracefully
}

//------------------------------------------------------------------------------

asio::awaitable<SessionResult> task_main_GET() {
    auto const host = "https://microsoftedge.github.io/Demos/json-dummy-data/64KB.json";
    auto const port = "443";
    auto const target = "/";

    std::osyncstream(std::cout) << "GET " << host << ":" << port << target << std::endl;
    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::tlsv12_client};

    // https://stackoverflow.com/a/61429566/2366975
    ctx.set_verify_mode(ssl::context::verify_peer);
    boost::certify::enable_native_https_server_verification(ctx);

    auto ex   = co_await this_coro::executor;
    auto task = co_spawn(
        ex,
        [&] -> asio::awaitable<std::string> {
            co_await do_session(host, port, target, ctx);
            co_return "some value, then";
        },
        asio::deferred);

    std::osyncstream(std::cout) << "response:\n" << co_await std::move(task) << std::endl;

    co_return; // TODO SessionResult
}

int main() try {
    asio::io_context ioc;

    co_spawn(ioc, task_main_GET, asio::detached);

    ioc.run();
} catch (std::exception const& e) {
    std::cerr << "Error: " << e.what() << "\n";
} catch (...) {
    std::cerr << "Unknown error\n";
}

    Isto compila (GCC 14, Boost 1.88). No entanto, tenho algumas perguntas:

    • seu eofcheque nunca é alcançado porque está na ifagência oposta

    • seu hostnão é um host, mas a https://....url inteira. opa, isso não pode resolver. Corrigindo:

       auto const host   = "microsoftedge.github.io";
 auto const port   = "443";
 auto const target = "/Demos/json-dummy-data/64KB.json";

    • por que o co_spawn quando você imediatamente co_awaitde qualquer maneira? Você poderia simplesmente substituir

       auto ex   = co_await this_coro::executor;
 auto task = co_spawn(
     ex,
     [&] -> asio::awaitable<std::string> {
         co_await do_session(host, port, target, ctx);
         co_return "some value, then";
     },
     asio::deferred);

 std::osyncstream(std::cout) << "response:\n" << co_await std::move(task) << std::endl;

      Com

      SessionResult data = co_await do_session(host, port, target, ctx);
std::osyncstream(std::cout) << "response:\n" << data << std::endl;

    • No meu sistema, o certificado do host não verifica com enable_native_https_server_verification. No entanto, ele faz isso com o próprio Asio

      // boost::certify::enable_native_https_server_verification(ctx);
ctx.set_default_verify_paths();

    Corrigindo isso (e provavelmente algumas outras coisas menores que esqueci):

    Ao vivo em Coliru

    
#include <boost/asio.hpp>
#include <boost/beast.hpp>
#include <boost/beast/ssl.hpp>
#include <iostream>
#include <syncstream> // added

namespace asio      = boost::asio;
namespace this_coro = asio::this_coro; // added
namespace beast     = boost::beast;    // from <boost/beast.hpp>
namespace http      = beast::http;     // from <boost/beast/http.hpp>
namespace ssl       = asio::ssl;       // from <boost/asio/ssl.hpp>
using asio::ip::tcp;                   // from <boost/asio/ip/tcp.hpp>
using beast::error_code;               // from <boost/beast/core.hpp>
using namespace std::chrono_literals;

//------------------------------------------------------------------------------

using SessionResult = std::string;

// Performs an HTTP GET and prints the response
asio::awaitable<SessionResult> do_session( //
    std::string host, std::string port, std::string target, ssl::context& ctx) {

    auto ex = co_await this_coro::executor;

    // These objects perform our I/O
    tcp::resolver resolver(ex);
    beast::ssl_stream<beast::tcp_stream> stream(ex, ctx);

    // Set SNI Hostname (many hosts need this to handshake successfully)
    if (!::SSL_set_tlsext_host_name(stream.native_handle(), host.c_str()))
        throw beast::system_error(static_cast<asio::error::ssl_errors>(::ERR_get_error()));

    // Look up the domain name
    auto const results = co_await resolver.async_resolve(host, port);

    // Set the timeout.
    beast::get_lowest_layer(stream).expires_after(30s);

    // Make the connection on the IP address we get from a lookup
    co_await beast::get_lowest_layer(stream).async_connect(results);

    // Perform the SSL handshake
    co_await stream.async_handshake(ssl::stream_base::client);

    // Set up an HTTP GET request message
    http::request<http::string_body> req{http::verb::get, target, 11};
    req.set(http::field::host, host);
    req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
    req.set(http::field::connection, "close");

    // Send the HTTP request to the remote host
    co_await http::async_write(stream, req);

    // This buffer is used for reading and must be persisted
    beast::flat_buffer b;

    // Declare a container to hold the response
    http::response<http::string_body> res;

    // Receive the HTTP response
    auto [ec, bytes] = co_await http::async_read(stream, b, res, asio::as_tuple);

    // eof is to be expected for some services
    if (ec && ec != asio::error::eof)
        throw beast::system_error(ec);

    // Write the message to standard out
    // std::cout << res << std::endl;

    // Gracefully close the stream
    std::tie(ec) = co_await stream.async_shutdown(asio::as_tuple);
    if (ec)
        std::cerr << "Shutdown: " << ec.message() << "\n";

    // If we get here then the connection is closed gracefully
    co_return std::move(res).body();
}

//------------------------------------------------------------------------------

asio::awaitable<SessionResult> GET() {
    auto const host   = "microsoftedge.github.io";
    auto const port   = "443";
    auto const target = "/Demos/json-dummy-data/64KB.json";

    std::osyncstream(std::cerr) << "GET " << host << ":" << port << target << std::endl;
    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::tlsv12_client};

    // https://stackoverflow.com/a/61429566/2366975
    ctx.set_verify_mode(ssl::context::verify_peer);
    // boost::certify::enable_native_https_server_verification(ctx);
    ctx.set_default_verify_paths();

    co_return co_await do_session(host, port, target, ctx);
}

int main() try {
    asio::io_context ioc;

    co_spawn(ioc, GET, [](std::exception_ptr ep, SessionResult result) {
        if (ep)
            rethrow_exception(ep);
        std::cout << result << "\n";
    });

    ioc.run();
} catch (std::exception const& e) {
    std::cerr << "Main Error: " << e.what() << "\n";
} catch (...) {
    std::cerr << "Main Unknown error\n";
}

    Demonstração local:

    insira a descrição da imagem aqui

    • 3

relate perguntas