Election flush

nano/core_test/election_scheduler.cpp

@@ -79,8 +79,11 @@ TEST (election_scheduler, no_vacancy)
 				   .work (*system.work.generate (key.pub))
 				   .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
+	nano::blocks_confirm (node, { send }, true);
+	ASSERT_TIMELY (1s, node.active.empty ());
 	ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
-	nano::blocks_confirm (node, { send, receive }, true);
+	nano::blocks_confirm (node, { receive }, true);
+	ASSERT_TIMELY (1s, node.active.empty ());
 
 	// Second, process two eligble transactions
 	auto block0 = builder.make_block ()
@@ -118,3 +121,28 @@ TEST (election_scheduler, no_vacancy)
 	auto election4 = node.active.election (block1->qualified_root ());
 	ASSERT_NE (nullptr, election4);
 }
+
+// Ensure that election_scheduler::flush terminates even if no elections can currently be queued e.g. shutdown or no active_transactions vacancy
+TEST (election_scheduler, flush_vacancy)
+{
+	nano::system system;
+	nano::node_config config{ nano::get_available_port (), system.logging };
+	// No elections can be activated
+	config.active_elections_size = 0;
+	auto & node = *system.add_node (config);
+	nano::state_block_builder builder;
+	nano::keypair key;
+
+	auto send = builder.make_block ()
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::genesis_hash)
+				.representative (nano::dev_genesis_key.pub)
+				.link (key.pub)
+				.balance (nano::genesis_amount - nano::Gxrb_ratio)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (nano::genesis_hash))
+				.build_shared ();
+	node.scheduler.manual (send);
+	// Ensure this call does not block, even though no elections can be activated.
+	node.scheduler.flush ();
+}

nano/node/election_scheduler.cpp

@@ -18,7 +18,7 @@ void nano::election_scheduler::manual (std::shared_ptr<nano::block> const & bloc
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
 	manual_queue.push_back (std::make_tuple (block_a, previous_balance_a, election_behavior_a, confirmation_action_a));
-	observe ();
+	notify ();
 }
 
 void nano::election_scheduler::activate (nano::account const & account_a, nano::transaction const & transaction)
@@ -39,7 +39,7 @@ void nano::election_scheduler::activate (nano::account const & account_a, nano::
 			{
 				nano::lock_guard<nano::mutex> lock{ mutex };
 				priority.push (account_info.modified, block);
-				observe ();
+				notify ();
 			}
 		}
 	}
@@ -49,20 +49,18 @@ void nano::election_scheduler::stop ()
 {
 	nano::unique_lock<nano::mutex> lock{ mutex };
 	stopped = true;
-	observe ();
+	notify ();
 }
 
 void nano::election_scheduler::flush ()
 {
 	nano::unique_lock<nano::mutex> lock{ mutex };
-	auto priority_target = priority_queued + priority.size ();
-	auto manual_target = manual_queued + manual_queue.size ();
-	condition.wait (lock, [this, &priority_target, &manual_target] () {
-		return priority_queued >= priority_target && manual_queued >= manual_target;
+	condition.wait (lock, [this] () {
+		return stopped || empty_locked () || node.active.vacancy () <= 0;
 	});
 }
 
-void nano::election_scheduler::observe ()
+void nano::election_scheduler::notify ()
 {
 	condition.notify_all ();
 }
@@ -73,10 +71,15 @@ size_t nano::election_scheduler::size () const
 	return priority.size () + manual_queue.size ();
 }
 
+bool nano::election_scheduler::empty_locked () const
+{
+	return priority.empty () && manual_queue.empty ();
+}
+
 bool nano::election_scheduler::empty () const
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
-	return priority.empty () && manual_queue.empty ();
+	return empty_locked ();
 }
 
 size_t nano::election_scheduler::priority_queue_size () const
@@ -120,7 +123,7 @@ void nano::election_scheduler::run ()
 				manual_queue.pop_front ();
 				++manual_queued;
 			}
-			observe ();
+			notify ();
 		}
 	}
 }

nano/node/election_scheduler.hpp

@@ -27,13 +27,14 @@ class election_scheduler final
 	void activate (nano::account const &, nano::transaction const &);
 	void stop ();
 	void flush ();
-	void observe ();
+	void notify ();
 	size_t size () const;
 	bool empty () const;
 	size_t priority_queue_size () const;
 
 private:
 	void run ();
+	bool empty_locked () const;
 	nano::prioritization priority;
 	uint64_t priority_queued{ 0 };
 	std::deque<std::tuple<std::shared_ptr<nano::block>, boost::optional<nano::uint128_t>, nano::election_behavior, std::function<void (std::shared_ptr<nano::block>)>>> manual_queue;

nano/node/node.cpp

@@ -127,7 +127,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co
 	{
 		telemetry->start ();
 
-		active.vacancy_update = [this] () { scheduler.observe (); };
+		active.vacancy_update = [this] () { scheduler.notify (); };
 
 		if (config.websocket_config.enabled)
 		{