feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity

Refactor HTTP serialization (API Change):

Browse Source 
A new class `serializer` is introduced to permit incremental
serialization of HTTP messages. Existing free functions are
re-implemented in terms of this new class.

* The BodyReader concept is refined to support a greater variety
of strategies for providing buffers representing the body to
the serialization algorithms.

* Added buffer_body, a new model of Body which allows the caller
to provide a series of owned buffers using their own serialization
loop.

* Added empty_body, a model of Body which is for serialization only,
to represent HTTP messages with no content body.

* Removed overloads of write and async_write which send only
the HTTP header.

* Removed public interfaces for performing low-level chunk encoding.
This commit is contained in:
Vinnie Falco
2017-07-20 08:12:17 -07:00
parent b9bdb1bbbc
commit 3664329ea7
44 changed files with 2540 additions and 1104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/http/write.cpp
+477 -94
View File
@@ -8,13 +8,16 @@
// Test that header file is self-contained.
#include <beast/http/write.hpp>
#include <beast/http/buffer_body.hpp>
#include <beast/http/fields.hpp>
#include <beast/http/message.hpp>
#include <beast/http/read.hpp>
#include <beast/http/string_body.hpp>
#include <beast/http/write.hpp>
#include <beast/core/error.hpp>
#include <beast/core/multi_buffer.hpp>
#include <beast/test/fail_stream.hpp>
#include <beast/test/pipe_stream.hpp>
#include <beast/test/string_istream.hpp>
#include <beast/test/string_ostream.hpp>
#include <beast/test/yield_to.hpp>
#include <beast/unit_test/suite.hpp>
@@ -39,25 +42,154 @@ public:
value_type const& body_;
public:
using is_deferred = std::false_type;
using const_buffers_type =
boost::asio::const_buffers_1;
template<bool isRequest, class Allocator>
explicit
writer(message<isRequest, unsized_body, Allocator> const& msg) noexcept
writer(message<isRequest, unsized_body, Allocator> const& msg)
: body_(msg.body)
{
}
void
init(error_code& ec) noexcept
init(error_code& ec)
{
beast::detail::ignore_unused(ec);
}
template<class WriteFunction>
bool
write(error_code&, WriteFunction&& wf) noexcept
boost::optional<std::pair<const_buffers_type, bool>>
get(error_code&)
{
wf(boost::asio::buffer(body_));
return true;
return {{const_buffers_type{
body_.data(), body_.size()}, false}};
}
};
};
template<
bool isDeferred,
bool isSplit,
bool isFinalEmpty
>
struct test_body
{
struct value_type
{
std::string s;
bool mutable read = false;
};
class writer
{
int step_ = 0;
value_type const& body_;
public:
using is_deferred =
std::integral_constant<bool, isDeferred>;
using const_buffers_type =
boost::asio::const_buffers_1;
template<bool isRequest, class Fields>
explicit
writer(message<isRequest, test_body,
Fields> const& msg)
: body_(msg.body)
{
}
void
init(error_code&)
{
}
boost::optional<std::pair<const_buffers_type, bool>>
get(error_code&)
{
body_.read = true;
return get(
std::integral_constant<bool, isSplit>{},
std::integral_constant<bool, isFinalEmpty>{});
}
private:
boost::optional<std::pair<const_buffers_type, bool>>
get(
std::false_type, // isSplit
std::false_type) // isFinalEmpty
{
using boost::asio::buffer;
if(body_.s.empty())
return boost::none;
return {{buffer(body_.s.data(), body_.s.size()), false}};
}
boost::optional<std::pair<const_buffers_type, bool>>
get(
std::false_type, // isSplit
std::true_type) // isFinalEmpty
{
using boost::asio::buffer;
if(body_.s.empty())
return boost::none;
switch(step_)
{
case 0:
step_ = 1;
return {{buffer(
body_.s.data(), body_.s.size()), true}};
default:
return boost::none;
}
}
boost::optional<std::pair<const_buffers_type, bool>>
get(
std::true_type, // isSplit
std::false_type) // isFinalEmpty
{
using boost::asio::buffer;
auto const n = (body_.s.size() + 1) / 2;
switch(step_)
{
case 0:
if(n == 0)
return boost::none;
step_ = 1;
return {{buffer(body_.s.data(), n),
body_.s.size() > 1}};
default:
return {{buffer(body_.s.data() + n,
body_.s.size() - n), false}};
}
}
boost::optional<std::pair<const_buffers_type, bool>>
get(
std::true_type, // isSplit
std::true_type) // isFinalEmpty
{
using boost::asio::buffer;
auto const n = (body_.s.size() + 1) / 2;
switch(step_)
{
case 0:
if(n == 0)
return boost::none;
step_ = body_.s.size() > 1 ? 1 : 2;
return {{buffer(body_.s.data(), n), true}};
case 1:
BOOST_ASSERT(body_.s.size() > 1);
step_ = 2;
return {{buffer(body_.s.data() + n,
body_.s.size() - n), true}};
default:
return boost::none;
}
}
};
};
@@ -72,22 +204,14 @@ public:
std::string s_;
test::fail_counter& fc_;
boost::asio::io_service& ios_;
public:
value_type(test::fail_counter& fc,
boost::asio::io_service& ios)
explicit
value_type(test::fail_counter& fc)
: fc_(fc)
, ios_(ios)
{
}
boost::asio::io_service&
get_io_service() const
{
return ios_;
}
value_type&
operator=(std::string s)
{
@@ -102,34 +226,57 @@ public:
value_type const& body_;
public:
using is_deferred = std::false_type;
using const_buffers_type =
boost::asio::const_buffers_1;
template<bool isRequest, class Allocator>
explicit
writer(message<isRequest, fail_body, Allocator> const& msg) noexcept
writer(message<isRequest, fail_body, Allocator> const& msg)
: body_(msg.body)
{
}
void
init(error_code& ec) noexcept
init(error_code& ec)
{
body_.fc_.fail(ec);
}
template<class WriteFunction>
bool
write(error_code& ec, WriteFunction&& wf) noexcept
boost::optional<std::pair<const_buffers_type, bool>>
get(error_code& ec)
{
if(body_.fc_.fail(ec))
return false;
return boost::none;
if(n_ >= body_.s_.size())
return true;
wf(boost::asio::buffer(body_.s_.data() + n_, 1));
++n_;
return n_ == body_.s_.size();
return boost::none;
return {{const_buffers_type{
body_.s_.data() + n_++, 1}, true}};
}
};
};
template<bool isRequest>
bool
equal_body(string_view sv, string_view body)
{
test::string_istream si{
get_io_service(), sv.to_string()};
message<isRequest, string_body, fields> m;
multi_buffer b;
try
{
read(si, b, m);
return m.body == body;
}
catch(std::exception const& e)
{
log << "equal_body: " << e.what() << std::endl;
return false;
}
}
template<bool isRequest, class Body, class Fields>
std::string
str(message<isRequest, Body, Fields> const& m)
@@ -139,43 +286,6 @@ public:
return ss.str;
}
void
testAsyncWriteHeaders(yield_context do_yield)
{
{
header<true, fields> m;
m.version = 11;
m.method("GET");
m.target("/");
m.fields.insert("User-Agent", "test");
error_code ec;
test::string_ostream ss{ios_};
async_write(ss, m, do_yield[ec]);
if(BEAST_EXPECTS(! ec, ec.message()))
BEAST_EXPECT(ss.str ==
"GET / HTTP/1.1\r\n"
"User-Agent: test\r\n"
"\r\n");
}
{
header<false, fields> m;
m.version = 10;
m.status = 200;
m.reason("OK");
m.fields.insert("Server", "test");
m.fields.insert("Content-Length", "5");
error_code ec;
test::string_ostream ss{ios_};
async_write(ss, m, do_yield[ec]);
if(BEAST_EXPECTS(! ec, ec.message()))
BEAST_EXPECT(ss.str ==
"HTTP/1.0 200 OK\r\n"
"Server: test\r\n"
"Content-Length: 5\r\n"
"\r\n");
}
}
void
testAsyncWrite(yield_context do_yield)
{
@@ -232,9 +342,7 @@ public:
test::fail_counter fc(n);
test::fail_stream<
test::string_ostream> fs(fc, ios_);
message<true, fail_body, fields> m(
std::piecewise_construct,
std::forward_as_tuple(fc, ios_));
message<true, fail_body, fields> m{fc};
m.method("GET");
m.target("/");
m.version = 10;
@@ -265,9 +373,7 @@ public:
test::fail_counter fc(n);
test::fail_stream<
test::string_ostream> fs(fc, ios_);
message<true, fail_body, fields> m(
std::piecewise_construct,
std::forward_as_tuple(fc, ios_));
message<true, fail_body, fields> m{fc};
m.method("GET");
m.target("/");
m.version = 10;
@@ -300,9 +406,7 @@ public:
test::fail_counter fc(n);
test::fail_stream<
test::string_ostream> fs(fc, ios_);
message<true, fail_body, fields> m(
std::piecewise_construct,
std::forward_as_tuple(fc, ios_));
message<true, fail_body, fields> m{fc};
m.method("GET");
m.target("/");
m.version = 10;
@@ -335,9 +439,7 @@ public:
test::fail_counter fc(n);
test::fail_stream<
test::string_ostream> fs(fc, ios_);
message<true, fail_body, fields> m(
std::piecewise_construct,
std::forward_as_tuple(fc, ios_));
message<true, fail_body, fields> m{fc};
m.method("GET");
m.target("/");
m.version = 10;
@@ -365,9 +467,7 @@ public:
test::fail_counter fc(n);
test::fail_stream<
test::string_ostream> fs(fc, ios_);
message<true, fail_body, fields> m(
std::piecewise_construct,
std::forward_as_tuple(fc, ios_));
message<true, fail_body, fields> m{fc};
m.method("GET");
m.target("/");
m.version = 10;
@@ -558,22 +658,15 @@ public:
"GET / HTTP/1.1\r\nUser-Agent: test\r\n\r\n*");
BEAST_EXPECT(boost::lexical_cast<std::string>(m.base()) ==
"GET / HTTP/1.1\r\nUser-Agent: test\r\n\r\n");
// Cause exceptions in operator<<
{
std::stringstream ss;
// header
ss << m.base();
// Cause exception in operator<<
ss.setstate(ss.rdstate() |
std::stringstream::failbit);
try
{
// header
ss << m.base();
fail("", __FILE__, __LINE__);
}
catch(std::exception const&)
{
pass();
}
try
{
// message
ss << m;
@@ -664,10 +757,287 @@ public:
}
}
template<class Stream,
bool isRequest, class Body, class Fields,
class Decorator = empty_decorator>
void
do_write(Stream& stream, message<
isRequest, Body, Fields> const& m, error_code& ec,
Decorator const& decorator = Decorator{})
{
auto ws = make_write_stream(m, decorator);
for(;;)
{
stream.nwrite = 0;
ws.write_some(stream, ec);
if(ec)
return;
BEAST_EXPECT(stream.nwrite <= 1);
if(ws.is_done())
break;
}
}
template<class Stream,
bool isRequest, class Body, class Fields,
class Decorator = empty_decorator>
void
do_async_write(Stream& stream,
message<isRequest, Body, Fields> const& m,
error_code& ec, yield_context yield,
Decorator const& decorator = Decorator{})
{
auto ws = make_write_stream(m);
for(;;)
{
stream.nwrite = 0;
ws.async_write_some(stream, yield[ec]);
if(ec)
return;
BEAST_EXPECT(stream.nwrite <= 1);
if(ws.is_done())
break;
}
}
struct test_decorator
{
template<class ConstBufferSequence>
string_view
operator()(ConstBufferSequence const&) const
{
return {";x\r\n"};
}
string_view
operator()(boost::asio::null_buffers) const
{
return {"F: v\r\n"};
}
};
template<class Body>
void
testWriteStream(boost::asio::yield_context yield)
{
test::pipe p{ios_};
p.client.write_size(3);
message<false, Body, fields> m0;
m0.version = 11;
m0.status = 200;
m0.reason("OK");
m0.fields.insert("Server", "test");
m0.body.s = "Hello, world!\n";
{
std::string const result =
"HTTP/1.1 200 OK\r\n"
"Server: test\r\n"
"\r\n"
"Hello, world!\n";
{
auto m = m0;
error_code ec;
do_write(p.client, m, ec);
BEAST_EXPECT(p.server.str() == result);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
do_async_write(p.client, m, ec, yield);
BEAST_EXPECT(p.server.str() == result);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
serializer<false, Body, fields> w{m};
w.split(true);
for(;;)
{
w.write_some(p.client);
if(w.is_header_done())
break;
}
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
{
auto m = m0;
error_code ec;
serializer<false, Body, fields> w{m};
w.split(true);
for(;;)
{
w.async_write_some(p.client, yield);
if(w.is_header_done())
break;
}
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
}
{
m0.fields.insert("Transfer-Encoding", "chunked");
{
auto m = m0;
error_code ec;
do_write(p.client, m, ec);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
do_write(p.client, m, ec, test_decorator{});
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
do_async_write(p.client, m, ec, yield);
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
do_async_write(p.client, m, ec, yield, test_decorator{});
BEAST_EXPECT(equal_body<false>(
p.server.str(), m.body.s));
p.server.clear();
}
{
auto m = m0;
error_code ec;
test::string_ostream so{get_io_service(), 3};
serializer<false, Body, fields> w{m};
w.split(true);
for(;;)
{
w.write_some(p.client);
if(w.is_header_done())
break;
}
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
{
auto m = m0;
error_code ec;
serializer<false, Body, fields> w{m};
w.split(true);
for(;;)
{
w.async_write_some(p.client, yield);
if(w.is_header_done())
break;
}
BEAST_EXPECT(! m.body.read);
p.server.clear();
}
}
}
/** Execute a child process and return the output as an HTTP response.
@param input A stream to read the child process output from.
@param output A stream to write the HTTP response to.
*/
template<class SyncReadStream, class SyncWriteStream>
void
cgi_process(SyncReadStream& input, SyncWriteStream& output, error_code& ec)
{
multi_buffer b;
message<false, buffer_body<true,
typename multi_buffer::const_buffers_type>, fields> m;
m.status = 200;
m.version = 11;
m.fields.insert("Server", "cgi-process");
m.fields.insert("Transfer-Encoding", "chunked");
m.body.first = boost::none;
m.body.second = true;
auto w = make_write_stream(m);
// send the header first, so the
// other end gets it right away
for(;;)
{
w.write_some(output, ec);
if(ec == error::need_more)
{
ec = {};
break;
}
if(ec)
return;
}
// send the body
for(;;)
{
// read from input
auto bytes_transferred =
input.read_some(b.prepare(1024), ec);
if(ec == boost::asio::error::eof)
{
BOOST_ASSERT(bytes_transferred == 0);
ec = {};
m.body = {boost::none, false};
}
else
{
if(ec)
return;
b.commit(bytes_transferred);
m.body = {b.data(), true};
}
// write to output
for(;;)
{
w.write_some(output, ec);
if(ec == error::need_more)
{
ec = {};
break;
}
if(ec)
return;
if(w.is_done())
goto is_done;
}
b.consume(b.size());
}
is_done:
;
}
void
testCgiRelay()
{
error_code ec;
std::string const body = "Hello, world!\n";
test::string_ostream so{get_io_service(), 3};
test::string_istream si{get_io_service(), body, 6};
cgi_process(si, so, ec);
BEAST_EXPECT(equal_body<false>(so.str, body));
}
void run() override
{
yield_to([&](yield_context yield){
testAsyncWriteHeaders(yield); });
yield_to([&](yield_context yield){
testAsyncWrite(yield); });
yield_to([&](yield_context yield){
@@ -676,6 +1046,19 @@ public:
test_std_ostream();
testOstream();
testIoService();
testCgiRelay();
yield_to(
[&](yield_context yield)
{
testWriteStream<test_body<false, false, false>>(yield);
testWriteStream<test_body<false, false, true>>(yield);
testWriteStream<test_body<false, true, false>>(yield);
testWriteStream<test_body<false, true, true>>(yield);
testWriteStream<test_body< true, false, false>>(yield);
testWriteStream<test_body< true, false, true>>(yield);
testWriteStream<test_body< true, true, false>>(yield);
testWriteStream<test_body< true, true, true>>(yield);
});
}
};