Passing socket by reference and callback by r-value reference.

Removing member variables for error and block result to make things less stateful.

nano/node/bootstrap/block_deserializer.cpp

@@ -8,59 +8,63 @@ nano::bootstrap::block_deserializer::block_deserializer () :
 {
 }
 
-void nano::bootstrap::block_deserializer::read (std::shared_ptr<nano::socket> socket, callback_type callback)
+void nano::bootstrap::block_deserializer::read (nano::socket & socket, callback_type const && callback)
 {
-	debug_assert (socket != nullptr);
 	debug_assert (callback);
-	reset ();
-	this->socket = socket;
 	read_buffer->resize (1);
-	socket->async_read (read_buffer, 1, [this_l = shared_from_this (), callback] (boost::system::error_code const & ec, std::size_t size_a) {
-		if (ec || size_a != 1)
+	socket.async_read (read_buffer, 1, [this_l = shared_from_this (), &socket, callback = std::move (callback)] (boost::system::error_code const & ec, std::size_t size_a) {
+		if (size_a != 1)
 		{
-			this_l->ec = ec;
-			callback (nullptr);
+			callback (boost::asio::error::fault, nullptr);
 			return;
 		}
-		this_l->received_type (callback);
+		if (ec)
+		{
+			callback (ec, nullptr);
+			return;
+		}
+		this_l->received_type (socket, std::move (callback));
 	});
 }
 
-void nano::bootstrap::block_deserializer::received_type (callback_type callback)
+void nano::bootstrap::block_deserializer::received_type (nano::socket & socket, callback_type const && callback)
 {
 	nano::block_type type = static_cast<nano::block_type> (read_buffer->data ()[0]);
 	if (type == nano::block_type::not_a_block)
 	{
-		callback (nullptr);
+		callback (boost::system::error_code{}, nullptr);
 		return;
 	}
 	auto size = block_size (type);
 	if (size == 0)
 	{
-		ec = boost::asio::error::fault;
-		callback (nullptr);
+		callback (boost::asio::error::fault, nullptr);
 		return;
 	}
 	read_buffer->resize (size);
-	socket->async_read (read_buffer, size, [this_l = shared_from_this (), size, type, callback] (boost::system::error_code const & ec, std::size_t size_a) {
-		if (ec || size_a != size)
+	socket.async_read (read_buffer, size, [this_l = shared_from_this (), size, type, callback = std::move (callback)] (boost::system::error_code const & ec, std::size_t size_a) {
+		if (size_a != size)
 		{
-			this_l->ec = ec;
-			callback (nullptr);
+			callback (boost::asio::error::fault, nullptr);
 			return;
 		}
-		this_l->received_block (type, callback);
+		if (ec)
+		{
+			callback (ec, nullptr);
+			return;
+		}
+		this_l->received_block (type, std::move (callback));
 	});
 }
 
-void nano::bootstrap::block_deserializer::received_block (nano::block_type type, callback_type callback)
+void nano::bootstrap::block_deserializer::received_block (nano::block_type type, callback_type const && callback)
 {
 	nano::bufferstream stream{ read_buffer->data (), read_buffer->size () };
-	block = nano::deserialize_block (stream, type);
-	callback (block);
+	auto block = nano::deserialize_block (stream, type);
+	callback (boost::system::error_code{}, block);
 }
 
-size_t nano::bootstrap::block_deserializer::block_size (nano::block_type type)
+std::size_t nano::bootstrap::block_deserializer::block_size (nano::block_type type)
 {
 	switch (type)
 	{
@@ -78,8 +82,3 @@ size_t nano::bootstrap::block_deserializer::block_size (nano::block_type type)
 			return 0;
 	}
 }
-
-void nano::bootstrap::block_deserializer::reset ()
-{
-	block.reset ();
-}

nano/node/bootstrap/block_deserializer.hpp

@@ -16,19 +16,18 @@ namespace bootstrap
 	class block_deserializer : public std::enable_shared_from_this<nano::bootstrap::block_deserializer>
 	{
 	public:
-		using callback_type = std::function<void (std::shared_ptr<nano::block>)>;
+		using callback_type = std::function<void (boost::system::error_code, std::shared_ptr<nano::block>)>;
 
 		block_deserializer ();
-		void read (std::shared_ptr<nano::socket> socket, callback_type callback);
-		void reset ();
-		std::shared_ptr<nano::block> block;
-		boost::system::error_code ec;
+		/**
+		 * Read a type-prefixed block from 'socket' and pass the result, or an error, to 'callback'
+		 */
+		void read (nano::socket & socket, callback_type const && callback);
 
 	private:
-		void received_type (callback_type callback);
-		void received_block (nano::block_type type, callback_type callback);
+		void received_type (nano::socket & socket, callback_type const && callback);
+		void received_block (nano::block_type type, callback_type const && callback);
 		size_t block_size (nano::block_type type);
-		std::shared_ptr<nano::socket> socket;
 		std::shared_ptr<std::vector<uint8_t>> read_buffer;
 	};
 }

nano/node/bootstrap/bootstrap_bulk_pull.cpp

@@ -123,18 +123,20 @@ void nano::bulk_pull_client::throttled_receive_block ()
 
 void nano::bulk_pull_client::receive_block ()
 {
-	block_deserializer->read (connection->socket, [this_l = shared_from_this ()] (std::shared_ptr<nano::block> block) { this_l->received_block (block); });
+	block_deserializer->read (*connection->socket, [this_l = shared_from_this ()] (boost::system::error_code ec, std::shared_ptr<nano::block> block) {
+		this_l->received_block (ec, block);
+	});
 }
 
-void nano::bulk_pull_client::received_block (std::shared_ptr<nano::block> block)
+void nano::bulk_pull_client::received_block (boost::system::error_code ec, std::shared_ptr<nano::block> block)
 {
+	if (ec)
+	{
+		network_error = true;
+		return;
+	}
 	if (block == nullptr)
 	{
-		if (block_deserializer->ec)
-		{
-			network_error = true;
-			return;
-		}
 		// Avoid re-using slow peers, or peers that sent the wrong blocks.
 		if (!connection->pending_stop && (expected == pull.end || (pull.count != 0 && pull.count == pull_blocks)))
 		{

nano/node/bootstrap/bootstrap_bulk_pull.hpp

@@ -41,7 +41,7 @@ class bulk_pull_client final : public std::enable_shared_from_this<nano::bulk_pu
 	void request ();
 	void receive_block ();
 	void throttled_receive_block ();
-	void received_block (std::shared_ptr<nano::block> block);
+	void received_block (boost::system::error_code ec, std::shared_ptr<nano::block> block);
 	nano::block_hash first ();
 	std::shared_ptr<nano::bootstrap_client> connection;
 	std::shared_ptr<nano::bootstrap_attempt> attempt;