From d8b8716a17ff0a0b5fcfe131cb1124c4a354dfe2 Mon Sep 17 00:00:00 2001 From: eidheim Date: Sun, 9 Jul 2017 12:54:56 +0200 Subject: [PATCH] Session and Connection cleanup --- client_http.hpp | 150 +++++++++++++++++++++++++------------------ client_https.hpp | 38 +++++------ server_http.hpp | 119 +++++++++++++++++----------------- server_https.hpp | 14 ++-- tests/parse_test.cpp | 2 +- 5 files changed, 172 insertions(+), 151 deletions(-) diff --git a/client_http.hpp b/client_http.hpp index 1bb13cc..10846b1 100644 --- a/client_http.hpp +++ b/client_http.hpp @@ -114,39 +114,30 @@ namespace SimpleWeb { }; protected: - class Connection { + class Connection : public std::enable_shared_from_this { public: template - Connection(Args &&... args) : socket(new socket_type(std::forward(args)...)) {} + Connection(std::shared_ptr cancel_handlers, std::shared_ptr cancel_handlers_mutex, long timeout, Args &&... args) + : cancel_handlers(std::move(cancel_handlers)), cancel_handlers_mutex(std::move(cancel_handlers_mutex)), timeout(timeout), + socket(new socket_type(std::forward(args)...)) {} + + std::shared_ptr cancel_handlers; + std::shared_ptr cancel_handlers_mutex; + long timeout; std::unique_ptr socket; // Socket must be unique_ptr since asio::ssl::stream is not movable std::mutex socket_close_mutex; bool in_use = false; bool attempt_reconnect = true; + std::unique_ptr timer; + void close() { error_code ec; std::unique_lock lock(socket_close_mutex); // the following operations seems to be needed to run sequentially socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec); socket->lowest_layer().close(ec); } - }; - - class Session { - public: - Session(std::shared_ptr cancel_handlers, std::shared_ptr cancel_handlers_mutex, long timeout, - std::shared_ptr connection, std::unique_ptr request_buffer) - : 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()) {} - std::shared_ptr cancel_handlers; - std::shared_ptr cancel_handlers_mutex; - long timeout; - - std::shared_ptr connection; - std::unique_ptr request_buffer; - std::shared_ptr response; - std::function callback; - std::unique_ptr timer; void set_timeout(long seconds = 0) { if(seconds == 0) @@ -155,13 +146,12 @@ namespace SimpleWeb { timer = nullptr; return; } - - auto timer = std::unique_ptr(new asio::deadline_timer(connection->socket->get_io_service())); + timer = std::unique_ptr(new asio::deadline_timer(socket->get_io_service())); timer->expires_from_now(boost::posix_time::seconds(seconds)); - auto connection = this->connection; - timer->async_wait([connection](const error_code &ec) { + auto self = this->shared_from_this(); + timer->async_wait([self](const error_code &ec) { if(!ec) - connection->close(); + self->close(); }); } @@ -169,6 +159,24 @@ namespace SimpleWeb { if(timer) timer->cancel(); } + + std::pair> cancel_handlers_bool_and_lock() { + if(!cancel_handlers) + return {false, nullptr}; + auto lock = cancel_handlers_mutex->shared_lock(); + return {*cancel_handlers, std::move(lock)}; + } + }; + + class Session { + public: + Session(std::shared_ptr connection, std::unique_ptr request_buffer) + : connection(std::move(connection)), request_buffer(std::move(request_buffer)), response(new Response()) {} + + std::shared_ptr connection; + std::unique_ptr request_buffer; + std::shared_ptr response; + std::function callback; }; public: @@ -243,7 +251,7 @@ namespace SimpleWeb { /// Do not use concurrently with the synchronous request functions. void request(const std::string &method, const std::string &path, string_view content, const CaseInsensitiveMultimap &header, std::function, const error_code &)> &&request_callback_) { - auto session = std::make_shared(cancel_handlers, cancel_handlers_mutex, config.timeout, get_connection(), create_request_header(method, path, header)); + auto session = std::make_shared(get_connection(), create_request_header(method, path, header)); auto connection = session->connection; auto response = session->response; auto request_callback = std::make_shared, const error_code &)>>(std::move(request_callback_)); @@ -301,7 +309,7 @@ namespace SimpleWeb { /// Asynchronous request where setting and/or running Client's io_service is required. void request(const std::string &method, const std::string &path, std::istream &content, const CaseInsensitiveMultimap &header, std::function, const error_code &)> &&request_callback_) { - auto session = std::make_shared(cancel_handlers, cancel_handlers_mutex, config.timeout, get_connection(), create_request_header(method, path, header)); + auto session = std::make_shared(get_connection(), create_request_header(method, path, header)); auto connection = session->connection; auto response = session->response; auto request_callback = std::make_shared, const error_code &)>>(std::move(request_callback_)); @@ -352,21 +360,27 @@ namespace SimpleWeb { void stop() { std::unique_lock lock(connections_mutex); for(auto it = connections.begin(); it != connections.end();) { - (*it)->attempt_reconnect = false; - (*it)->close(); + if(!internal_io_service) { + (*it)->attempt_reconnect = false; + (*it)->close(); + } it = connections.erase(it); } } virtual ~ClientBase() { { - auto lock = cancel_handlers_mutex->unique_lock(); - *cancel_handlers = true; + if(!internal_io_service) { + auto lock = cancel_handlers_mutex->unique_lock(); + *cancel_handlers = true; + } } stop(); } protected: + bool internal_io_service = false; + std::string host; unsigned short port; @@ -381,7 +395,7 @@ namespace SimpleWeb { size_t concurrent_synchronous_requests = 0; std::mutex concurrent_synchronous_requests_mutex; - ClientBase(const std::string &host_port, unsigned short default_port) : io_service(new asio::io_service()), cancel_handlers(new bool(false)), cancel_handlers_mutex(new SharedMutex()) { + ClientBase(const std::string &host_port, unsigned short default_port) : cancel_handlers(new bool(false)), cancel_handlers_mutex(new SharedMutex()) { auto parsed_host_port = parse_host_port(host_port, default_port); host = parsed_host_port.first; port = parsed_host_port.second; @@ -390,6 +404,14 @@ namespace SimpleWeb { std::shared_ptr get_connection() { std::shared_ptr connection; std::unique_lock lock(connections_mutex); + + if(!io_service) { + io_service = std::make_shared(); + internal_io_service = true; + cancel_handlers = nullptr; + cancel_handlers_mutex = nullptr; + } + for(auto it = connections.begin(); it != connections.end(); ++it) { if(!(*it)->in_use && !connection) { connection = *it; @@ -449,11 +471,11 @@ namespace SimpleWeb { } void write(const std::shared_ptr &session) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_write(*session->connection->socket, session->request_buffer->data(), [this, session](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) this->read(session); @@ -465,11 +487,11 @@ namespace SimpleWeb { } void read(const std::shared_ptr &session) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n\r\n", [this, session](const error_code &ec, size_t bytes_transferred) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { session->connection->attempt_reconnect = true; @@ -482,11 +504,11 @@ namespace SimpleWeb { if(header_it != session->response->header.end()) { auto content_length = stoull(header_it->second); if(content_length > num_additional_bytes) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(content_length - num_additional_bytes), [this, session](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) session->callback(ec); @@ -504,11 +526,11 @@ namespace SimpleWeb { this->read_chunked(session, tmp_streambuf); } else if(session->response->http_version < "1.1" || ((header_it = session->response->header.find("Session")) != session->response->header.end() && header_it->second == "close")) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_read(*session->connection->socket, session->response->content_buffer, [this, session](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) session->callback(ec); @@ -541,11 +563,11 @@ namespace SimpleWeb { } void read_chunked(const std::shared_ptr &session, const std::shared_ptr &tmp_streambuf) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n", [this, session, tmp_streambuf](const error_code &ec, size_t bytes_transferred) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { std::string line; @@ -579,11 +601,11 @@ namespace SimpleWeb { }; if((2 + length) > num_additional_bytes) { - session->set_timeout(); + session->connection->set_timeout(); asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(2 + length - num_additional_bytes), [this, session, post_process](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) post_process(); @@ -616,24 +638,24 @@ namespace SimpleWeb { protected: std::shared_ptr create_connection() override { - return std::make_shared(*io_service); + return std::make_shared(cancel_handlers, cancel_handlers_mutex, config.timeout, *io_service); } void connect(const std::shared_ptr &session) override { if(!session->connection->socket->lowest_layer().is_open()) { auto resolver = std::make_shared(*io_service); - session->set_timeout(config.timeout_connect); + session->connection->set_timeout(config.timeout_connect); resolver->async_resolve(*query, [this, session, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator it) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { - session->set_timeout(config.timeout_connect); + session->connection->set_timeout(config.timeout_connect); asio::async_connect(*session->connection->socket, it, [this, session, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator /*it*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { asio::ip::tcp::no_delay option(true); diff --git a/client_https.hpp b/client_https.hpp index 35bf10a..32b511c 100644 --- a/client_https.hpp +++ b/client_https.hpp @@ -41,22 +41,22 @@ namespace SimpleWeb { asio::ssl::context context; std::shared_ptr create_connection() override { - return std::make_shared(*io_service, context); + return std::make_shared(cancel_handlers, cancel_handlers_mutex, config.timeout, *io_service, context); } void connect(const std::shared_ptr &session) override { if(!session->connection->socket->lowest_layer().is_open()) { auto resolver = std::make_shared(*io_service); resolver->async_resolve(*query, [this, session, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator it) { - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { - session->set_timeout(this->config.timeout_connect); + session->connection->set_timeout(this->config.timeout_connect); asio::async_connect(session->connection->socket->lowest_layer(), it, [this, session, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator /*it*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { asio::ip::tcp::no_delay option(true); @@ -69,19 +69,19 @@ namespace SimpleWeb { auto host_port = this->host + ':' + std::to_string(this->port); write_stream << "CONNECT " + host_port + " HTTP/1.1\r\n" << "Host: " << host_port << "\r\n\r\n"; - session->set_timeout(this->config.timeout_connect); + session->connection->set_timeout(this->config.timeout_connect); asio::async_write(session->connection->socket->next_layer(), *write_buffer, [this, session, write_buffer](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { std::shared_ptr response(new Response()); - session->set_timeout(this->config.timeout_connect); + session->connection->set_timeout(this->config.timeout_connect); asio::async_read_until(session->connection->socket->next_layer(), response->content_buffer, "\r\n\r\n", [this, session, response](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { response->parse_header(); @@ -124,11 +124,11 @@ namespace SimpleWeb { } void handshake(const std::shared_ptr &session) { - session->set_timeout(this->config.timeout_connect); + session->connection->set_timeout(this->config.timeout_connect); session->connection->socket->async_handshake(asio::ssl::stream_base::client, [this, session](const error_code &ec) { - session->cancel_timeout(); - auto lock = session->cancel_handlers_mutex->shared_lock(); - if(*session->cancel_handlers) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) this->write(session); diff --git a/server_http.hpp b/server_http.hpp index a2a7b05..9560210 100644 --- a/server_http.hpp +++ b/server_http.hpp @@ -50,7 +50,7 @@ namespace SimpleWeb { class Session; public: - class Response : public std::ostream { + class Response : public std::enable_shared_from_this, public std::ostream { friend class ServerBase; friend class Server; @@ -86,15 +86,12 @@ namespace SimpleWeb { /// Use this function if you need to recursively send parts of a longer message void send(const std::function &callback = nullptr) { - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) - return; - session->set_timeout(timeout_content); - auto session = this->session; - asio::async_write(*session->connection->socket, streambuf, [session, callback](const error_code &ec, size_t /*bytes_transferred*/) { - session->cancel_timeout(); - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + session->connection->set_timeout(timeout_content); + auto self = this->shared_from_this(); // Keep Response instance alive through the following async_write + asio::async_write(*session->connection->socket, streambuf, [self, callback](const error_code &ec, size_t /*bytes_transferred*/) { + self->session->connection->cancel_timeout(); + auto cancel_pair = self->session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(callback) callback(ec); @@ -258,26 +255,58 @@ namespace SimpleWeb { }; protected: - class Connection { + class Connection : public std::enable_shared_from_this { public: template - Connection(Args &&... args) : socket(new socket_type(std::forward(args)...)) {} + Connection(std::shared_ptr cancel_handlers, std::shared_ptr cancel_handlers_mutex, Args &&... args) + : cancel_handlers(std::move(cancel_handlers)), cancel_handlers_mutex(std::move(cancel_handlers_mutex)), socket(new socket_type(std::forward(args)...)) {} + + std::shared_ptr cancel_handlers; + std::shared_ptr cancel_handlers_mutex; std::unique_ptr socket; // Socket must be unique_ptr since asio::ssl::stream is not movable std::mutex socket_close_mutex; + std::unique_ptr timer; + void close() { error_code ec; std::unique_lock lock(socket_close_mutex); // the following operations seems to be needed to run sequentially socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec); socket->lowest_layer().close(ec); } + + void set_timeout(long seconds) { + if(seconds == 0) { + timer = nullptr; + return; + } + + timer = std::unique_ptr(new asio::deadline_timer(socket->get_io_service())); + timer->expires_from_now(boost::posix_time::seconds(seconds)); + auto self = this->shared_from_this(); + timer->async_wait([self](const error_code &ec) { + if(!ec) + self->close(); + }); + } + + void cancel_timeout() { + if(timer) + timer->cancel(); + } + + std::pair> cancel_handlers_bool_and_lock() { + if(!cancel_handlers) + return {false, nullptr}; + auto lock = cancel_handlers_mutex->shared_lock(); + return {*cancel_handlers, std::move(lock)}; + } }; class Session { public: - Session(std::shared_ptr cancel_handlers, std::shared_ptr cancel_handlers_mutex, std::shared_ptr connection) - : cancel_handlers(std::move(cancel_handlers)), cancel_handlers_mutex(std::move(cancel_handlers_mutex)), connection(std::move(connection)) { + Session(std::shared_ptr connection) : connection(std::move(connection)) { try { auto remote_endpoint = this->connection->socket->lowest_layer().remote_endpoint(); request = std::shared_ptr(new Request(remote_endpoint.address().to_string(), remote_endpoint.port())); @@ -287,39 +316,8 @@ namespace SimpleWeb { } } - std::shared_ptr cancel_handlers; - std::shared_ptr cancel_handlers_mutex; - std::shared_ptr connection; std::shared_ptr request; - std::unique_ptr timer; - - std::pair> 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) { - if(seconds == 0) { - timer = nullptr; - return; - } - - timer = std::unique_ptr(new asio::deadline_timer(connection->socket->get_io_service())); - timer->expires_from_now(boost::posix_time::seconds(seconds)); - auto connection = this->connection; - timer->async_wait([connection](const error_code &ec) { - if(!ec) - connection->close(); - }); - } - - void cancel_timeout() { - if(timer) - timer->cancel(); - } }; public: @@ -377,6 +375,7 @@ namespace SimpleWeb { io_service = std::make_shared(); internal_io_service = true; cancel_handlers = nullptr; + cancel_handlers_mutex = nullptr; } if(io_service->stopped()) @@ -463,7 +462,7 @@ namespace SimpleWeb { std::shared_ptr create_connection(Args &&... args) { auto connections = this->connections; auto connections_mutex = this->connections_mutex; - auto connection = std::shared_ptr(new Connection(std::forward(args)...), [connections, connections_mutex](Connection *connection) { + auto connection = std::shared_ptr(new Connection(cancel_handlers, cancel_handlers_mutex, std::forward(args)...), [connections, connections_mutex](Connection *connection) { { std::unique_lock lock(*connections_mutex); auto it = connections->find(connection); @@ -480,11 +479,11 @@ namespace SimpleWeb { } void read_request_and_content(const std::shared_ptr &session) { - session->set_timeout(config.timeout_request); + session->connection->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) { - session->cancel_timeout(); - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) { //request->streambuf.size() is not necessarily the same as bytes_transferred, from Boost-docs: @@ -509,11 +508,11 @@ namespace SimpleWeb { return; } if(content_length > num_additional_bytes) { - session->set_timeout(config.timeout_content); + session->connection->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*/) { - session->cancel_timeout(); - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) this->find_resource(session); @@ -560,7 +559,7 @@ namespace SimpleWeb { void write_response(const std::shared_ptr &session, std::function::Response>, std::shared_ptr::Request>)> &resource_function) { - session->set_timeout(config.timeout_content); + session->connection->set_timeout(config.timeout_content); auto response = std::shared_ptr(new Response(session, config.timeout_content), [this](Response *response_ptr) { auto response = std::shared_ptr(response_ptr); response->send([this, response](const error_code &ec) { @@ -573,13 +572,13 @@ namespace SimpleWeb { if(case_insensitive_equal(it->second, "close")) return; else if(case_insensitive_equal(it->second, "keep-alive")) { - auto new_session = std::make_shared(this->cancel_handlers, this->cancel_handlers_mutex, response->session->connection); + auto new_session = std::make_shared(response->session->connection); this->read_request_and_content(new_session); return; } } if(response->session->request->http_version >= "1.1") { - auto new_session = std::make_shared(this->cancel_handlers, this->cancel_handlers_mutex, response->session->connection); + auto new_session = std::make_shared(response->session->connection); this->read_request_and_content(new_session); return; } @@ -612,11 +611,11 @@ namespace SimpleWeb { protected: void accept() override { - auto session = std::make_shared(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service)); + auto session = std::make_shared(create_connection(*io_service)); acceptor->async_accept(*session->connection->socket, [this, session](const error_code &ec) { - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; //Immediately start accepting a new connection (unless io_service has been stopped) diff --git a/server_https.hpp b/server_https.hpp index 805709d..f247308 100644 --- a/server_https.hpp +++ b/server_https.hpp @@ -48,11 +48,11 @@ namespace SimpleWeb { asio::ssl::context context; void accept() override { - auto session = std::make_shared(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service, context)); + auto session = std::make_shared(create_connection(*io_service, context)); acceptor->async_accept(session->connection->socket->lowest_layer(), [this, session](const error_code &ec) { - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(ec != asio::error::operation_aborted) @@ -63,11 +63,11 @@ namespace SimpleWeb { error_code ec; session->connection->socket->lowest_layer().set_option(option, ec); - session->set_timeout(config.timeout_request); + session->connection->set_timeout(config.timeout_request); session->connection->socket->async_handshake(asio::ssl::stream_base::server, [this, session](const error_code &ec) { - session->cancel_timeout(); - auto cancel = session->cancel_handlers_and_lock(); - if(cancel.first) + session->connection->cancel_timeout(); + auto cancel_pair = session->connection->cancel_handlers_bool_and_lock(); + if(cancel_pair.first) return; if(!ec) this->read_request_and_content(session); diff --git a/tests/parse_test.cpp b/tests/parse_test.cpp index 8318aba..935e295 100644 --- a/tests/parse_test.cpp +++ b/tests/parse_test.cpp @@ -13,7 +13,7 @@ public: void accept() override {} void parse_request_test() { - auto session = std::make_shared(cancel_handlers, cancel_handlers_mutex, create_connection(*io_service)); + auto session = std::make_shared(create_connection(*io_service)); std::ostream stream(&session->request->content.streambuf); stream << "GET /test/ HTTP/1.1\r\n";