How to construct a boost::beast::http::message from std::string?

Question

Is that possible to construct a boost::beast::http::message (specifically I have to construct a boost::beast::http::response<bb_http::string_body>) from std::string, std::string_view or other raw buffer?

Maybe there is some kind of parser? From what I see in Boost.Beast samples, we can either:

1. receive a response from boost::beast::read* functions. In that case the first argument should be a SyncReadStream, which has to comply with contracts of SyncReadStream from boost/beast/core/type_traits.hpp:

struct is_sync_read_stream<T, detail::void_t<decltype(
    std::declval<std::size_t&>() = std::declval<T>().read_some(
        std::declval<detail::MutableBufferSequence>()),
    std::declval<std::size_t&>() = std::declval<T>().read_some(
        std::declval<detail::MutableBufferSequence>(),
        std::declval<boost::system::error_code&>()),
            (void)0)>> : std::true_type {};

2. or construct it by hand like http::request<http::string_body> req{http::verb::get, target, version};

Answer 1

You can manually invoke the parser, e.g. with this simple skeleton function:

http::response<http::string_body> do_parse(std::string_view input)
{
    beast::error_code ec;
    http::response_parser<http::string_body> p;

    // read headers
    auto buf = boost::asio::buffer(sample);
    auto n = p.put(buf, ec);
    assert(p.is_header_done());

    // read body
    if (!ec) {
        buf += n;
        n = p.put(buf, ec);
        p.put_eof(ec);
    }
    if (ec)
        throw boost::system::system_error(ec);
    assert(p.is_done());

    return p.release();
}

This assumes that input is a sinlge complete request.

Live Demo

Live On Coliru

#include <boost/beast.hpp>
#include <boost/beast/http.hpp>
#include <string_view>
#include <iostream>
#include <iomanip>
namespace beast = boost::beast;
namespace http = beast::http;

http::response<http::string_body> do_parse(std::string_view input)
{
    beast::error_code ec;
    http::response_parser<http::string_body> p;

    // read headers
    auto buf = boost::asio::buffer(input);
    auto n   = p.put(buf, ec);
    assert(p.is_header_done());

    // read body
    if (!ec) {
        buf += n;
        n = p.put(buf, ec);
        p.put_eof(ec);
    }
    if (ec)
        throw boost::system::system_error(ec);
    assert(p.is_done());

    return p.release();
}

int main() {
    auto res = do_parse(
        "HTTP/1.1 200 OK\r\n"
        "Date: Sun, 10 Oct 2010 23:26:07 GMT\r\n"
        "Server: Apache/2.2.8 (Ubuntu) mod_ssl/2.2.8 OpenSSL/0.9.8g\r\n"
        "Last-Modified: Sun, 26 Sep 2010 22:04:35 GMT\r\n"
        "ETag: 45b6-834-49130cc1182c0\r\n"
        "Accept-Ranges: bytes\r\n"
        "Content-Length: 12\r\n"
        "Connection: close\r\n"
        "Content-Type: text/html\r\n"
        "\r\n"
        "Hello world!");
    std::cout << res << '\n';
    std::cout << "====== body:\n" << std::quoted(res.body()) << "\n";
}

Prints

HTTP/1.1 200 OK
Date: Sun, 10 Oct 2010 23:26:07 GMT
Server: Apache/2.2.8 (Ubuntu) mod_ssl/2.2.8 OpenSSL/0.9.8g
Last-Modified: Sun, 26 Sep 2010 22:04:35 GMT
ETag: 45b6-834-49130cc1182c0
Accept-Ranges: bytes
Content-Length: 12
Connection: close
Content-Type: text/html
Hello world!
====== body:
"Hello world!"

Answer 2

Turns out there already has been a sample snippet for reading a boost::beast::message from std::istream. https://www.boost.org/doc/libs/1_66_0/libs/beast/doc/html/beast/using_http/buffer_oriented_parsing.html

/** Read a message from a `std::istream`.

    This function attempts to parse a complete HTTP/1 message from the stream.

    @param is The `std::istream` to read from.

    @param buffer The buffer to use.

    @param msg The message to store the result.

    @param ec Set to the error, if any occurred.
*/
template<
    class Allocator,
    bool isRequest,
    class Body>
void
read_istream(
    std::istream& is,
    basic_flat_buffer<Allocator>& buffer,
    message<isRequest, Body, fields>& msg,
    error_code& ec)
{
    // Create the message parser
    //
    // Arguments passed to the parser's constructor are
    // forwarded to the message constructor. Here, we use
    // a move construction in case the caller has constructed
    // their message in a non-default way.
    //
    parser<isRequest, Body> p{std::move(msg)};

    do
    {
        // Extract whatever characters are presently available in the istream
        if(is.rdbuf()->in_avail() > 0)
        {
            // Get a mutable buffer sequence for writing
            auto const b = buffer.prepare(
                static_cast<std::size_t>(is.rdbuf()->in_avail()));

            // Now get everything we can from the istream
            buffer.commit(static_cast<std::size_t>(is.readsome(
                reinterpret_cast<char*>(b.data()), b.size())));
        }
        else if(buffer.size() == 0)
        {
            // Our buffer is empty and we need more characters, 
            // see if we've reached the end of file on the istream
            if(! is.eof())
            {
                // Get a mutable buffer sequence for writing
                auto const b = buffer.prepare(1024);

                // Try to get more from the istream. This might block.
                is.read(reinterpret_cast<char*>(b.data()), b.size());

                // If an error occurs on the istream then return it to the caller.
                if(is.fail() && ! is.eof())
                {
                    // We'll just re-use io_error since std::istream has no error_code interface.
                    ec = make_error_code(errc::io_error);
                    return;
                }

                // Commit the characters we got to the buffer.
                buffer.commit(static_cast<std::size_t>(is.gcount()));
            }
            else
            {
                // Inform the parser that we've reached the end of the istream.
                p.put_eof(ec);
                if(ec)
                    return;
                break;
            }
        }

        // Write the data to the parser
        auto const bytes_used = p.put(buffer.data(), ec);

        // This error means that the parser needs additional octets.
        if(ec == error::need_more)
            ec = {};
        if(ec)
            return;

        // Consume the buffer octets that were actually parsed.
        buffer.consume(bytes_used);
    }
    while(! p.is_done());

    // Transfer ownership of the message container in the parser to the caller.
    msg = p.release();
}