- Make the cWebem instance to wait for all connections to stop

gracefully ;
- Ignore exceptions while canceling timers ;
- Ignore exceptions while closing socket (on connection stop).
- Ignore exceptions while stopping acceptor.

Author: gaudryc

webserver/cWebem.cpp

@@ -97,7 +97,13 @@ void cWebem::Stop() {
 	}
 	// Stop Web server
 	if (myServer != NULL) {
-		myServer->stop();
+		myServer->stop(); // asynchronous stop
+		while(true) {
+			sleep_milliseconds(100);
+			if (myServer->stopped()) {
+				break;
+			}
+		}
 	}
 }
 

webserver/connection.cpp

@@ -22,13 +22,17 @@ namespace server {
 
 // this is the constructor for plain connections
 connection::connection(boost::asio::io_service& io_service,
-    connection_manager& manager, request_handler& handler, int timeout)
-  : connection_manager_(manager),
-    request_handler_(handler),
-	timeout_(timeout),
-	timer_(io_service, boost::posix_time::seconds( timeout )),
-	default_abandoned_timeout_(20*60), // 20mn before stopping abandoned connection
-	abandoned_timer_(io_service, boost::posix_time::seconds(default_abandoned_timeout_))
+		connection_manager& manager,
+		request_handler& handler,
+		int read_timeout) :
+				connection_manager_(manager),
+				request_handler_(handler),
+				read_timeout_(read_timeout),
+				read_timer_(io_service, boost::posix_time::seconds(read_timeout)),
+				default_abandoned_timeout_(20*60), // 20mn before stopping abandoned connection
+				abandoned_timer_(io_service, boost::posix_time::seconds(default_abandoned_timeout_)),
+				status("initializing"),
+				stop_required(false)
 {
 	secure_ = false;
 	keepalive_ = false;
@@ -41,13 +45,18 @@ connection::connection(boost::asio::io_service& io_service,
 #ifdef WWW_ENABLE_SSL
 // this is the constructor for secure connections
 connection::connection(boost::asio::io_service& io_service,
-    connection_manager& manager, request_handler& handler, int timeout, boost::asio::ssl::context& context)
-  : connection_manager_(manager),
-    request_handler_(handler),
-	timeout_(timeout),
-	timer_(io_service, boost::posix_time::seconds( timeout )),
-	default_abandoned_timeout_(20*60), // 20mn before stopping abandoned connection
-	abandoned_timer_(io_service, boost::posix_time::seconds(default_abandoned_timeout_))
+		connection_manager& manager,
+		request_handler& handler,
+		int read_timeout,
+		boost::asio::ssl::context& context) :
+				connection_manager_(manager),
+				request_handler_(handler),
+				read_timeout_(read_timeout),
+				read_timer_(io_service, boost::posix_time::seconds(read_timeout)),
+				default_abandoned_timeout_(20*60), // 20mn before stopping abandoned connection
+				abandoned_timer_(io_service, boost::posix_time::seconds(default_abandoned_timeout_)),
+				status("initializing"),
+				stop_required(false)
 {
 	secure_ = true;
 	keepalive_ = false;
@@ -85,11 +94,13 @@ void connection::start()
 		connection_manager_.stop(shared_from_this());
 		return;
 	}
+	host_endpoint_ = endpoint.address().to_string();
 
 	set_abandoned_timeout();
-	host_endpoint_ = endpoint.address().to_string();
+
 	if (secure_) {
 #ifdef WWW_ENABLE_SSL
+		status = "waiting-handshake";
 		// with ssl, we first need to complete the handshake before reading
 		sslsocket_->async_handshake(boost::asio::ssl::stream_base::server,
 			boost::bind(&connection::handle_handshake, shared_from_this(),
@@ -106,25 +117,23 @@ void connection::stop()
 {
 	// Cancel timers
 	cancel_abandoned_timeout();
-	timer_.cancel();
+	cancel_read_timeout();
 
-	// Initiate graceful connection closure.
-	boost::system::error_code ignored_ec;
-	socket().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec); // @note For portable behaviour with respect to graceful closure of a
-																				// connected socket, call shutdown() before closing the socket.
-	socket().close();
-}
-
-void connection::handle_timeout(const boost::system::error_code& error)
-{
-		if (error != boost::asio::error::operation_aborted) {
-			connection_manager_.stop(shared_from_this());
-		}
+	try {
+		// Initiate graceful connection closure.
+		boost::system::error_code ignored_ec;
+		socket().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec); // @note For portable behaviour with respect to graceful closure of a
+																					// connected socket, call shutdown() before closing the socket.
+		socket().close(ignored_ec);
+	} catch(...) {
+		_log.Log(LOG_ERROR, "%s -> exception thrown while stopping connection", host_endpoint_.c_str());
+	}
 }
 
 #ifdef WWW_ENABLE_SSL
 void connection::handle_handshake(const boost::system::error_code& error)
 {
+	status = "handshaking";
     if (secure_) { // assert
 		if (!error)
 		{
@@ -141,12 +150,16 @@ void connection::handle_handshake(const boost::system::error_code& error)
 
 void connection::read_more()
 {
+	status = "waiting-read";
+	if (is_stopping()) {
+		return;
+	}
+
 	// read chunks of max 4 KB
 	boost::asio::streambuf::mutable_buffers_type buf = _buf.prepare(4096);
 
 	// set timeout timer
-	timer_.expires_from_now(boost::posix_time::seconds(timeout_));
-	timer_.async_wait(boost::bind(&connection::handle_timeout, shared_from_this(), boost::asio::placeholders::error));
+	reset_read_timeout();
 
 	if (secure_) {
 #ifdef WWW_ENABLE_SSL
@@ -168,8 +181,14 @@ void connection::read_more()
 
 void connection::handle_read(const boost::system::error_code& error, std::size_t bytes_transferred)
 {
+	status = "reading";
+	if (is_stopping()) {
+		return;
+	}
+
 	// data read, no need for timeouts (RK, note: race condition)
-	timer_.cancel();
+	cancel_read_timeout();
+
     if (!error && bytes_transferred > 0)
     {
 		// ensure written bytes in the buffer
@@ -201,6 +220,12 @@ void connection::handle_read(const boost::system::error_code& error, std::size_t
 				request_.host = request_.host.substr(7);
 			}
 			request_handler_.handle_request(request_, reply_);
+
+			status = "waiting-write";
+			if (is_stopping()) {
+				return;
+			}
+
 			if (secure_) {
 #ifdef WWW_ENABLE_SSL
 				boost::asio::async_write(*sslsocket_, reply_.to_buffers(request_.method),
@@ -218,6 +243,12 @@ void connection::handle_read(const boost::system::error_code& error, std::size_t
 		{
 			keepalive_ = false;
 			reply_ = reply::stock_reply(reply::bad_request);
+
+			status = "writing";
+			if (is_stopping()) {
+				return;
+			}
+
 			if (secure_) {
 #ifdef WWW_ENABLE_SSL
 				boost::asio::async_write(*sslsocket_, reply_.to_buffers(request_.method),
@@ -244,7 +275,7 @@ void connection::handle_read(const boost::system::error_code& error, std::size_t
 
 void connection::handle_write(const boost::system::error_code& error)
 {
-	if (!error && keepalive_) {
+	if (!error && keepalive_ && !stop_required) {
 		// if a keep-alive connection is requested, we read the next request
 		read_more();
 	} else {
@@ -261,6 +292,39 @@ connection::~connection()
 #endif
 }
 
+// schedule read timeout timer
+void connection::set_read_timeout() {
+	read_timer_.expires_from_now(boost::posix_time::seconds(read_timeout_));
+	read_timer_.async_wait(boost::bind(&connection::handle_read_timeout, shared_from_this(), boost::asio::placeholders::error));
+}
+
+/// simply cancel read timeout timer
+void connection::cancel_read_timeout() {
+	try {
+		boost::system::error_code ignored_ec;
+		read_timer_.cancel(ignored_ec);
+		if (ignored_ec) {
+			_log.Log(LOG_ERROR, "%s -> exception thrown while canceling read timeout : %s", host_endpoint_.c_str(), ignored_ec.message().c_str());
+		}
+	} catch (...) {
+		_log.Log(LOG_ERROR, "%s -> exception thrown while canceling read timeout", host_endpoint_.c_str());
+	}
+}
+
+/// reschedule read timeout timer
+void connection::reset_read_timeout() {
+	cancel_read_timeout();
+	set_read_timeout();
+}
+
+/// stop connection on read timeout
+void connection::handle_read_timeout(const boost::system::error_code& error) {
+	if (error != boost::asio::error::operation_aborted) {
+		_log.Log(LOG_STATUS, "%s -> handle read timeout", host_endpoint_.c_str());
+		connection_manager_.stop(shared_from_this());
+	}
+}
+
 /// schedule abandoned timeout timer
 void connection::set_abandoned_timeout() {
 	abandoned_timer_.expires_from_now(boost::posix_time::seconds(default_abandoned_timeout_));
@@ -269,7 +333,15 @@ void connection::set_abandoned_timeout() {
 
 /// simply cancel abandoned timeout timer
 void connection::cancel_abandoned_timeout() {
-	abandoned_timer_.cancel();
+	try {
+		boost::system::error_code ignored_ec;
+		abandoned_timer_.cancel(ignored_ec);
+		if (ignored_ec) {
+			_log.Log(LOG_ERROR, "%s -> exception thrown while canceling abandoned timeout : %s", host_endpoint_.c_str(), ignored_ec.message().c_str());
+		}
+	} catch (...) {
+		_log.Log(LOG_ERROR, "%s -> exception thrown while canceling abandoned timeout", host_endpoint_.c_str());
+	}
 }
 
 /// reschedule abandoned timeout timer
@@ -286,5 +358,19 @@ void connection::handle_abandoned_timeout(const boost::system::error_code& error
 	}
 }
 
+/// Wait for all asynchronous operations to abort.
+void connection::stop_gracefully() {
+	stop_required = true;
+}
+
+/// stop the connection if it is required
+bool connection::is_stopping() {
+	if (stop_required) {
+		connection_manager_.stop(shared_from_this());
+		return true;
+	}
+	return false;
+}
+
 } // namespace server
 } // namespace http

webserver/connection.hpp

@@ -58,8 +58,11 @@ class connection
   /// Stop all asynchronous operations associated with the connection.
   void stop();
 
+  /// Wait for all asynchronous operations to abort.
+  void stop_gracefully();
+
   /// Timer handlers
-  void handle_timeout(const boost::system::error_code& error);
+  void handle_read_timeout(const boost::system::error_code& error);
   void handle_abandoned_timeout(const boost::system::error_code& error);
 
 private:
@@ -70,6 +73,12 @@ class connection
   /// Handle completion of a write operation.
   void handle_write(const boost::system::error_code& e);
 
+	/// Initialize read timeout timer
+	void set_read_timeout();
+	/// Stop read timeout timer
+	void cancel_read_timeout();
+	/// Reset read timeout timer
+	void reset_read_timeout();
 
 	/// Schedule abandoned timeout timer
 	void set_abandoned_timeout();
@@ -78,6 +87,9 @@ class connection
 	/// Reschedule abandoned timeout timer
 	void reset_abandoned_timeout();
 
+	/// Check if the connection is about to stop
+	bool is_stopping();
+
   /// Socket for the (PLAIN) connection.
   boost::asio::ip::tcp::socket *socket_;
   //Host EndPoint
@@ -87,10 +99,10 @@ class connection
   bool keepalive_;
 
   /// Read timeout in seconds
-  int timeout_;
+  int read_timeout_;
 
   /// Read timeout timer
-  boost::asio::deadline_timer timer_;
+  boost::asio::deadline_timer read_timer_;
 
   /// Abandoned connection timeout (in seconds)
   long default_abandoned_timeout_;
@@ -112,6 +124,12 @@ class connection
   /// The buffer that we receive data in
   boost::asio::streambuf _buf;
 
+  /// The status of the connection (can be initializing, handshaking, waiting, reading, writing)
+  std::string status;
+
+  /// Ask the connection to stop as soon as possible
+  bool stop_required;
+
   // secure connection members below
   // secure connection yes/no
   bool secure_;

webserver/connection_manager.cpp

@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <boost/bind.hpp>
 #include <iostream>
+#include "../main/Helper.h"
 #include "../main/Logger.h"
 #include "../main/localtime_r.h"
 
@@ -52,11 +53,31 @@ void connection_manager::stop(connection_ptr c)
 	c->stop();
 }
 
-void connection_manager::stop_all()
+void connection_manager::stop_all(bool graceful_stop)
 {
-  std::for_each(connections_.begin(), connections_.end(),
-      boost::bind(&connection::stop, _1));
-  connections_.clear();
+	_log.Log(LOG_STATUS,"connection_manager::stop_all(%s)", graceful_stop ? "true" : "false");
+	if (graceful_stop) {
+		std::for_each(connections_.begin(), connections_.end(),
+				boost::bind(&connection::stop_gracefully, _1));
+		int timeout = 10; // force stop after 10 seconds
+		time_t start = mytime(NULL);
+		while(true) {
+			if (connections_.size() < 1) {
+				break;
+			}
+			if ((mytime(NULL) - start) > timeout) {
+				// timeout occurred : force stop
+				_log.Log(LOG_STATUS,"Graceful stop timeout occurred : all connections will be closed now");
+				break;
+			}
+			_log.Log(LOG_STATUS,"Graceful stopping : %d active connection(s)", (int) connections_.size());
+			sleep_milliseconds(500);
+		}
+	}
+	std::for_each(connections_.begin(), connections_.end(),
+			boost::bind(&connection::stop, _1));
+	connections_.clear();
+	_log.Log(LOG_STATUS,"connection_manager::stop_all(%s) ends", graceful_stop ? "true" : "false");
 }
 
 

webserver/connection_manager.hpp

@@ -31,7 +31,7 @@ class connection_manager
   void stop(connection_ptr c);
 
   /// Stop all connections.
-  void stop_all();
+  void stop_all(bool graceful_stop);
 
 private:
   /// The managed connections.