jyapayne/Simple-Web-Server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Shared mutex is no longer used when using internal io_service

Browse source
This commit is contained in:
eidheim 2017-07-09 08:34:53 +02:00
commit dfd7895328
3 changed files with 28 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

3
client_http.hpp
View file

@ -138,15 +138,14 @@ namespace SimpleWeb {
std::shared_ptr<Connection> connection, std::unique_ptr<asio::streambuf> request_buffer) std::shared_ptr<Connection> connection, std::unique_ptr<asio::streambuf> request_buffer)
: cancel_handlers(std::move(cancel_handlers)), cancel_handlers_mutex(std::move(cancel_handlers_mutex)), timeout(timeout), : cancel_handlers(std::move(cancel_handlers)), cancel_handlers_mutex(std::move(cancel_handlers_mutex)), timeout(timeout),
connection(std::move(connection)), request_buffer(std::move(request_buffer)), response(new Response()) {} connection(std::move(connection)), request_buffer(std::move(request_buffer)), response(new Response()) {}
ClientBase<socket_type> *client;
std::shared_ptr<bool> cancel_handlers; std::shared_ptr<bool> cancel_handlers;
std::shared_ptr<SharedMutex> cancel_handlers_mutex; std::shared_ptr<SharedMutex> cancel_handlers_mutex;
long timeout; long timeout;
std::shared_ptr<Connection> connection; std::shared_ptr<Connection> connection;
std::unique_ptr<asio::streambuf> request_buffer; std::unique_ptr<asio::streambuf> request_buffer;
std::shared_ptr<Response> response; std::shared_ptr<Response> response;
std::function<void(const error_code &)> callback; std::function<void(const error_code &)> callback;
std::unique_ptr<asio::deadline_timer> timer; std::unique_ptr<asio::deadline_timer> timer;
void set_timeout(long seconds = 0) { void set_timeout(long seconds = 0) {

32
server_http.hpp
View file

@ -86,15 +86,15 @@ namespace SimpleWeb {
/// Use this function if you need to recursively send parts of a longer message /// Use this function if you need to recursively send parts of a longer message
void send(const std::function<void(const error_code &)> &callback = nullptr) { void send(const std::function<void(const error_code &)> &callback = nullptr) {
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
session->set_timeout(timeout_content); session->set_timeout(timeout_content);
auto session = this->session; auto session = this->session;
asio::async_write(*session->connection->socket, streambuf, [session, callback](const error_code &ec, size_t /*bytes_transferred*/) { asio::async_write(*session->connection->socket, streambuf, [session, callback](const error_code &ec, size_t /*bytes_transferred*/) {
session->cancel_timeout(); session->cancel_timeout();
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
if(callback) if(callback)
callback(ec); callback(ec);
@ -289,11 +289,18 @@ namespace SimpleWeb {
std::shared_ptr<bool> cancel_handlers; std::shared_ptr<bool> cancel_handlers;
std::shared_ptr<SharedMutex> cancel_handlers_mutex; std::shared_ptr<SharedMutex> cancel_handlers_mutex;
std::shared_ptr<Connection> connection; std::shared_ptr<Connection> connection;
std::shared_ptr<Request> request; std::shared_ptr<Request> request;
std::unique_ptr<asio::deadline_timer> timer; std::unique_ptr<asio::deadline_timer> timer;
std::pair<bool, std::unique_ptr<SharedMutex::SharedLock>> cancel_handlers_and_lock() {
if(!cancel_handlers)
return {false, nullptr};
auto lock = cancel_handlers_mutex->shared_lock();
return {*cancel_handlers, std::move(lock)};
}
void set_timeout(long seconds) { void set_timeout(long seconds) {
if(seconds == 0) { if(seconds == 0) {
timer = nullptr; timer = nullptr;
@ -369,6 +376,7 @@ namespace SimpleWeb {
if(!io_service) { if(!io_service) {
io_service = std::make_shared<asio::io_service>(); io_service = std::make_shared<asio::io_service>();
internal_io_service = true; internal_io_service = true;
cancel_handlers = nullptr;
} }
if(io_service->stopped()) if(io_service->stopped())
@ -426,9 +434,11 @@ namespace SimpleWeb {
virtual ~ServerBase() { virtual ~ServerBase() {
{ {
if(!internal_io_service) {
auto lock = cancel_handlers_mutex->unique_lock(); auto lock = cancel_handlers_mutex->unique_lock();
*cancel_handlers = true; *cancel_handlers = true;
} }
}
stop(); stop();
} }
@ -473,8 +483,8 @@ namespace SimpleWeb {
session->set_timeout(config.timeout_request); session->set_timeout(config.timeout_request);
asio::async_read_until(*session->connection->socket, session->request->streambuf, "\r\n\r\n", [this, session](const error_code &ec, size_t bytes_transferred) { asio::async_read_until(*session->connection->socket, session->request->streambuf, "\r\n\r\n", [this, session](const error_code &ec, size_t bytes_transferred) {
session->cancel_timeout(); session->cancel_timeout();
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
if(!ec) { if(!ec) {
//request->streambuf.size() is not necessarily the same as bytes_transferred, from Boost-docs: //request->streambuf.size() is not necessarily the same as bytes_transferred, from Boost-docs:
@ -502,8 +512,8 @@ namespace SimpleWeb {
session->set_timeout(config.timeout_content); session->set_timeout(config.timeout_content);
asio::async_read(*session->connection->socket, session->request->streambuf, asio::transfer_exactly(content_length - num_additional_bytes), [this, session](const error_code &ec, size_t /*bytes_transferred*/) { asio::async_read(*session->connection->socket, session->request->streambuf, asio::transfer_exactly(content_length - num_additional_bytes), [this, session](const error_code &ec, size_t /*bytes_transferred*/) {
session->cancel_timeout(); session->cancel_timeout();
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
if(!ec) if(!ec)
this->find_resource(session); this->find_resource(session);
@ -605,8 +615,8 @@ namespace SimpleWeb {
auto session = std::make_shared<Session>(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service)); auto session = std::make_shared<Session>(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service));
acceptor->async_accept(*session->connection->socket, [this, session](const error_code &ec) { acceptor->async_accept(*session->connection->socket, [this, session](const error_code &ec) {
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
//Immediately start accepting a new connection (unless io_service has been stopped) //Immediately start accepting a new connection (unless io_service has been stopped)

8
server_https.hpp
View file

@ -51,8 +51,8 @@ namespace SimpleWeb {
auto session = std::make_shared<Session>(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service, context)); auto session = std::make_shared<Session>(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service, context));
acceptor->async_accept(session->connection->socket->lowest_layer(), [this, session](const error_code &ec) { acceptor->async_accept(session->connection->socket->lowest_layer(), [this, session](const error_code &ec) {
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
if(ec != asio::error::operation_aborted) if(ec != asio::error::operation_aborted)
@ -66,8 +66,8 @@ namespace SimpleWeb {
session->set_timeout(config.timeout_request); session->set_timeout(config.timeout_request);
session->connection->socket->async_handshake(asio::ssl::stream_base::server, [this, session](const error_code &ec) { session->connection->socket->async_handshake(asio::ssl::stream_base::server, [this, session](const error_code &ec) {
session->cancel_timeout(); session->cancel_timeout();
auto lock = session->cancel_handlers_mutex->shared_lock(); auto cancel = session->cancel_handlers_and_lock();
if(*session->cancel_handlers) if(cancel.first)
return; return;
if(!ec) if(!ec)
this->read_request_and_content(session); this->read_request_and_content(session);