Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Formatted the code.

Browse Source
This commit is contained in:
Denis Chaplygin 2019-08-19 16:27:45 +03:00
parent 22550d078f
commit a7b7d77e1f
2 changed files with 51 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/server/connection.hpp
View File

@ -69,7 +69,7 @@ class Connection : public std::enable_shared_from_this<Connection>
std::vector<char> compressed_output; std::vector<char> compressed_output;
// Header compression_header; // Header compression_header;
std::vector<boost::asio::const_buffer> output_buffer; std::vector<boost::asio::const_buffer> output_buffer;
//Keep alive support // Keep alive support
bool keep_alive = false; bool keep_alive = false;
short processed_requests = 512; short processed_requests = 512;
short keepalive_timeout = 5; // In seconds short keepalive_timeout = 5; // In seconds

96
src/server/connection.cpp
View File

@ -2,16 +2,16 @@
#include "server/request_handler.hpp" #include "server/request_handler.hpp"
#include "server/request_parser.hpp" #include "server/request_parser.hpp"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/iostreams/filter/gzip.hpp> #include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filtering_stream.hpp> #include <boost/iostreams/filtering_stream.hpp>
#include <iterator> #include <iterator>
#include <string> #include <string>
#include <vector>
#include <util/log.hpp> #include <util/log.hpp>
#include <vector>
namespace osrm namespace osrm
{ {
@ -29,18 +29,16 @@ boost::asio::ip::tcp::socket &Connection::socket() { return TCP_socket; }
void Connection::start() void Connection::start()
{ {
TCP_socket.async_read_some( TCP_socket.async_read_some(
boost::asio::buffer(incoming_data_buffer), boost::asio::buffer(incoming_data_buffer),
strand.wrap(boost::bind(&Connection::handle_read, strand.wrap(boost::bind(&Connection::handle_read,
this->shared_from_this(), this->shared_from_this(),
boost::asio::placeholders::error, boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred))); boost::asio::placeholders::bytes_transferred)));
//init async timer // init async timer
timer.cancel(); timer.cancel();
timer.expires_from_now(boost::posix_time::seconds(keepalive_timeout)); timer.expires_from_now(boost::posix_time::seconds(keepalive_timeout));
timer.async_wait(boost::bind(&Connection::handle_timeout, timer.async_wait(boost::bind(&Connection::handle_timeout, this->shared_from_this()));
this->shared_from_this()));
} }
void Connection::handle_read(const boost::system::error_code &error, std::size_t bytes_transferred) void Connection::handle_read(const boost::system::error_code &error, std::size_t bytes_transferred)
@ -54,9 +52,9 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
http::compression_type compression_type(http::no_compression); http::compression_type compression_type(http::no_compression);
RequestParser::RequestStatus result; RequestParser::RequestStatus result;
std::tie(result, compression_type) = std::tie(result, compression_type) =
request_parser.parse(current_request, request_parser.parse(current_request,
incoming_data_buffer.data(), incoming_data_buffer.data(),
incoming_data_buffer.data() + bytes_transferred); incoming_data_buffer.data() + bytes_transferred);
// the request has been parsed // the request has been parsed
if (result == RequestParser::RequestStatus::valid) if (result == RequestParser::RequestStatus::valid)
@ -64,9 +62,12 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
current_request.endpoint = TCP_socket.remote_endpoint().address(); current_request.endpoint = TCP_socket.remote_endpoint().address();
request_handler.HandleRequest(current_request, current_reply); request_handler.HandleRequest(current_request, current_reply);
if (boost::iequals(current_request.connection, "close")) { if (boost::iequals(current_request.connection, "close"))
{
current_reply.headers.emplace_back("Connection", "close"); current_reply.headers.emplace_back("Connection", "close");
} else { }
else
{
keep_alive = true; keep_alive = true;
current_reply.headers.emplace_back("Connection", "keep-alive"); current_reply.headers.emplace_back("Connection", "keep-alive");
current_reply.headers.emplace_back("Keep-Alive", "timeout=5, max=512"); current_reply.headers.emplace_back("Keep-Alive", "timeout=5, max=512");
@ -75,29 +76,29 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
// compress the result w/ gzip/deflate if requested // compress the result w/ gzip/deflate if requested
switch (compression_type) switch (compression_type)
{ {
case http::deflate_rfc1951: case http::deflate_rfc1951:
// use deflate for compression // use deflate for compression
current_reply.headers.insert(current_reply.headers.begin(), current_reply.headers.insert(current_reply.headers.begin(),
{"Content-Encoding", "deflate"}); {"Content-Encoding", "deflate"});
compressed_output = compress_buffers(current_reply.content, compression_type); compressed_output = compress_buffers(current_reply.content, compression_type);
current_reply.set_size(static_cast<unsigned>(compressed_output.size())); current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
output_buffer = current_reply.headers_to_buffers(); output_buffer = current_reply.headers_to_buffers();
output_buffer.push_back(boost::asio::buffer(compressed_output)); output_buffer.push_back(boost::asio::buffer(compressed_output));
break; break;
case http::gzip_rfc1952: case http::gzip_rfc1952:
// use gzip for compression // use gzip for compression
current_reply.headers.insert(current_reply.headers.begin(), current_reply.headers.insert(current_reply.headers.begin(),
{"Content-Encoding", "gzip"}); {"Content-Encoding", "gzip"});
compressed_output = compress_buffers(current_reply.content, compression_type); compressed_output = compress_buffers(current_reply.content, compression_type);
current_reply.set_size(static_cast<unsigned>(compressed_output.size())); current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
output_buffer = current_reply.headers_to_buffers(); output_buffer = current_reply.headers_to_buffers();
output_buffer.push_back(boost::asio::buffer(compressed_output)); output_buffer.push_back(boost::asio::buffer(compressed_output));
break; break;
case http::no_compression: case http::no_compression:
// don't use any compression // don't use any compression
current_reply.set_uncompressed_size(); current_reply.set_uncompressed_size();
output_buffer = current_reply.to_buffers(); output_buffer = current_reply.to_buffers();
break; break;
} }
// write result to stream // write result to stream
boost::asio::async_write(TCP_socket, boost::asio::async_write(TCP_socket,
@ -120,11 +121,11 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
{ {
// we don't have a result yet, so continue reading // we don't have a result yet, so continue reading
TCP_socket.async_read_some( TCP_socket.async_read_some(
boost::asio::buffer(incoming_data_buffer), boost::asio::buffer(incoming_data_buffer),
strand.wrap(boost::bind(&Connection::handle_read, strand.wrap(boost::bind(&Connection::handle_read,
this->shared_from_this(), this->shared_from_this(),
boost::asio::placeholders::error, boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred))); boost::asio::placeholders::bytes_transferred)));
} }
} }
@ -133,12 +134,15 @@ void Connection::handle_write(const boost::system::error_code &error)
{ {
if (!error) if (!error)
{ {
if (keep_alive && processed_requests > 0) { if (keep_alive && processed_requests > 0)
{
--processed_requests; --processed_requests;
current_request = http::request(); current_request = http::request();
request_parser = RequestParser(); request_parser = RequestParser();
this->start(); this->start();
} else { }
else
{
// Initiate graceful connection closure. // Initiate graceful connection closure.
handle_timeout(); handle_timeout();
} }