void Connection::handle_read(const boost::system::error_code &error, std::size_t bytes_transferred)
{
if (error)
{
return;
}
// no error detected, let's parse the request
CompressionType compression_type(noCompression);
boost::tribool result;
boost::tie(result, boost::tuples::ignore) =
RequestParser().Parse(request,
incoming_data_buffer.data(),
incoming_data_buffer.data() + bytes_transferred,
compression_type);
// the request has been parsed
if (result)
{
request.endpoint = TCP_socket.remote_endpoint().address();
request_handler.handle_request(request, reply);
// Header compression_header;
std::vector<char> compressed_output;
std::vector<boost::asio::const_buffer> output_buffer;
// compress the result w/ gzip/deflate if requested
switch (compression_type)
{
case deflateRFC1951:
// use deflate for compression
reply.headers.insert(reply.headers.begin(), {"Content-Encoding", "deflate"});
CompressBufferCollection(reply.content, compression_type, compressed_output);
reply.SetSize(static_cast<unsigned>(compressed_output.size()));
output_buffer = reply.HeaderstoBuffers();
output_buffer.push_back(boost::asio::buffer(compressed_output));
break;
case gzipRFC1952:
// use gzip for compression
reply.headers.insert(reply.headers.begin(), {"Content-Encoding", "gzip"});
CompressBufferCollection(reply.content, compression_type, compressed_output);
reply.SetSize(static_cast<unsigned>(compressed_output.size()));
output_buffer = reply.HeaderstoBuffers();
output_buffer.push_back(boost::asio::buffer(compressed_output));
break;
case noCompression:
// don't use any compression
reply.SetUncompressedSize();
output_buffer = reply.ToBuffers();
break;
}
// write result to stream
boost::asio::async_write(TCP_socket,
output_buffer,
strand.wrap(boost::bind(&Connection::handle_write,
this->shared_from_this(),
boost::asio::placeholders::error)));
}
else if (!result)
{ // request is not parseable
reply = Reply::StockReply(Reply::badRequest);
boost::asio::async_write(TCP_socket,
reply.ToBuffers(),
strand.wrap(boost::bind(&Connection::handle_write,
this->shared_from_this(),
boost::asio::placeholders::error)));
}
else
{
// we don't have a result yet, so continue reading
TCP_socket.async_read_some(
boost::asio::buffer(incoming_data_buffer),
strand.wrap(boost::bind(&Connection::handle_read,
this->shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
}
void Connection::handle_read(const boost::system::error_code &error, std::size_t bytes_transferred)
{
if (error)
{
return;
}
// no error detected, let's parse the request
compression_type compression_type(no_compression);
osrm::tribool result;
std::tie(result, compression_type) =
request_parser.parse(current_request, incoming_data_buffer.data(),
incoming_data_buffer.data() + bytes_transferred);
// the request has been parsed
if (result == osrm::tribool::yes)
{
current_request.endpoint = TCP_socket.remote_endpoint().address();
request_handler.handle_request(current_request, current_reply);
// Header compression_header;
std::vector<boost::asio::const_buffer> output_buffer;
// compress the result w/ gzip/deflate if requested
switch (compression_type)
{
case deflate_rfc1951:
// use deflate for compression
current_reply.headers.insert(current_reply.headers.begin(),
{"Content-Encoding", "deflate"});
compressed_output = compress_buffers(current_reply.content, compression_type);
current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
output_buffer = current_reply.headers_to_buffers();
output_buffer.push_back(boost::asio::buffer(compressed_output));
break;
case gzip_rfc1952:
// use gzip for compression
current_reply.headers.insert(current_reply.headers.begin(),
{"Content-Encoding", "gzip"});
compressed_output = compress_buffers(current_reply.content, compression_type);
current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
output_buffer = current_reply.headers_to_buffers();
output_buffer.push_back(boost::asio::buffer(compressed_output));
break;
case no_compression:
// don't use any compression
current_reply.set_uncompressed_size();
output_buffer = current_reply.to_buffers();
break;
}
// write result to stream
boost::asio::async_write(
TCP_socket, output_buffer,
strand.wrap(boost::bind(&Connection::handle_write, this->shared_from_this(),
boost::asio::placeholders::error)));
}
else if (result == osrm::tribool::no)
{ // request is not parseable
current_reply = reply::stock_reply(reply::bad_request);
boost::asio::async_write(
TCP_socket, current_reply.to_buffers(),
strand.wrap(boost::bind(&Connection::handle_write, this->shared_from_this(),
boost::asio::placeholders::error)));
}
else
{
// we don't have a result yet, so continue reading
TCP_socket.async_read_some(
boost::asio::buffer(incoming_data_buffer),
strand.wrap(boost::bind(&Connection::handle_read, this->shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
}
