Update slow_test

nano/node/blockprocessor.cpp

@@ -294,7 +294,7 @@ void nano::block_processor::process_batch (std::unique_lock<std::mutex> & lock_a
 			{
 				// Replace our block with the winner and roll back any dependent blocks
 				node.logger.always_log (boost::str (boost::format ("Rolling back %1% and replacing with %2%") % successor->hash ().to_string () % hash.to_string ()));
-				std::vector<nano::block_hash> rollback_list;
+				std::vector<std::shared_ptr<nano::block>> rollback_list;
 				if (node.ledger.rollback (transaction, successor->hash (), rollback_list))
 				{
 					node.logger.always_log (nano::severity_level::error, boost::str (boost::format ("Failed to roll back %1% because it or a successor was confirmed") % successor->hash ().to_string ()));
@@ -317,10 +317,12 @@ void nano::block_processor::process_batch (std::unique_lock<std::mutex> & lock_a
 					}
 				}
 				lock_a.unlock ();
-				// Deleting from votes cache
+				// Deleting from votes cache & wallet work watcher, stop active transaction
 				for (auto & i : rollback_list)
 				{
-					node.votes_cache.remove (i);
+					node.votes_cache.remove (i->hash ());
+					node.wallets.watcher.remove (i);
+					node.active.erase (*i);
 				}
 			}
 		}

nano/node/testing.cpp

@@ -239,8 +239,14 @@ void nano::system::generate_rollback (nano::node & node_a, std::vector<nano::acc
 		{
 			accounts_a[index] = accounts_a[accounts_a.size () - 1];
 			accounts_a.pop_back ();
-			auto error = node_a.ledger.rollback (transaction, hash);
+			std::vector<std::shared_ptr<nano::block>> rollback_list;
+			auto error = node_a.ledger.rollback (transaction, hash, rollback_list);
 			assert (!error);
+			for (auto & i : rollback_list)
+			{
+				node_a.wallets.watcher.remove (i);
+				node_a.active.erase (*i);
+			}
 		}
 	}
 }

nano/node/wallet.cpp

@@ -1412,12 +1412,17 @@ void nano::work_watcher::run ()
 		{
 			std::unique_lock<std::mutex> active_lock (node.active.mutex);
 			auto confirmed (false);
-			auto existing (node.active.roots.find ((i->second)->qualified_root ()));
+			auto existing (node.active.roots.find (i->first));
 			if (node.active.roots.end () != existing)
 			{
 				//block may not be in existing yet
 				confirmed = existing->election->confirmed.load ();
 			}
+			else if (i->second == nullptr)
+			{
+				// removed
+				confirmed = true;
+			}
 			else
 			{
 				//and so we fall back to ledger confirmation
@@ -1442,9 +1447,13 @@ void nano::work_watcher::run ()
 		for (auto & i : blocks)
 		{
 			uint64_t difficulty (0);
-			auto root = i.second->root ();
-			nano::work_validate (root, i.second->block_work (), &difficulty);
-			if (node.active.active_difficulty () > difficulty)
+			nano::block_hash root (0);
+			if (i.second != nullptr)
+			{
+				root = i.second->root ();
+				nano::work_validate (root, i.second->block_work (), &difficulty);
+			}
+			if (node.active.active_difficulty () > difficulty && i.second != nullptr)
 			{
 				auto qualified_root = i.second->qualified_root ();
 				auto hash = i.second->hash ();
@@ -1466,7 +1475,7 @@ void nano::work_watcher::run ()
 							{
 								election->status.winner = block;
 							}
-							auto current (election->blocks.find (block->hash ()));
+							auto current (election->blocks.find (hash));
 							assert (current != election->blocks.end ());
 							current->second = block;
 						}
@@ -1478,7 +1487,10 @@ void nano::work_watcher::run ()
 					{
 						break;
 					}
-					i.second = block;
+					if (i.second != nullptr)
+					{
+						i.second = block;
+					}
 					lock.unlock ();
 				}
 				lock.lock ();
@@ -1501,6 +1513,17 @@ void nano::work_watcher::add (std::shared_ptr<nano::block> block_a)
 	}
 }
 
+void nano::work_watcher::remove (std::shared_ptr<nano::block> block_a)
+{
+	auto root (block_a->qualified_root ());
+	std::lock_guard<std::mutex> lock (mutex);
+	auto existing (blocks.find (root));
+	if (existing != blocks.end () && existing->second->hash () == block_a->hash ())
+	{
+		existing->second = nullptr;
+	}
+}
+
 bool nano::work_watcher::is_watched (nano::qualified_root const & root_a)
 {
 	std::unique_lock<std::mutex> lock (mutex);

nano/node/wallet.hpp

@@ -170,6 +170,7 @@ class work_watcher
 	void stop ();
 	void run ();
 	void add (std::shared_ptr<nano::block>);
+	void remove (std::shared_ptr<nano::block>);
 	bool is_watched (nano::qualified_root const &);
 	std::mutex mutex;
 	nano::node & node;

nano/secure/ledger.cpp

@@ -12,7 +12,7 @@ namespace
 class rollback_visitor : public nano::block_visitor
 {
 public:
-	rollback_visitor (nano::transaction const & transaction_a, nano::ledger & ledger_a, std::vector<nano::block_hash> & list_a) :
+	rollback_visitor (nano::transaction const & transaction_a, nano::ledger & ledger_a, std::vector<std::shared_ptr<nano::block>> & list_a) :
 	transaction (transaction_a),
 	ledger (ledger_a),
 	list (list_a)
@@ -153,7 +153,7 @@ class rollback_visitor : public nano::block_visitor
 	}
 	nano::transaction const & transaction;
 	nano::ledger & ledger;
-	std::vector<nano::block_hash> & list;
+	std::vector<std::shared_ptr<nano::block>> & list;
 	bool error{ false };
 };
 
@@ -832,7 +832,7 @@ nano::uint128_t nano::ledger::weight (nano::transaction const & transaction_a, n
 }
 
 // Rollback blocks until `block_a' doesn't exist or it tries to penetrate the confirmation height
-bool nano::ledger::rollback (nano::transaction const & transaction_a, nano::block_hash const & block_a, std::vector<nano::block_hash> & list_a)
+bool nano::ledger::rollback (nano::transaction const & transaction_a, nano::block_hash const & block_a, std::vector<std::shared_ptr<nano::block>> & list_a)
 {
 	assert (store.block_exists (transaction_a, block_a));
 	auto account_l (account (transaction_a, block_a));
@@ -847,7 +847,7 @@ bool nano::ledger::rollback (nano::transaction const & transaction_a, nano::bloc
 		if (block_account_height > account_info.confirmation_height)
 		{
 			auto block (store.block_get (transaction_a, account_info.head));
-			list_a.push_back (account_info.head);
+			list_a.push_back (block);
 			block->visit (rollback);
 			error = rollback.error;
 		}
@@ -861,7 +861,7 @@ bool nano::ledger::rollback (nano::transaction const & transaction_a, nano::bloc
 
 bool nano::ledger::rollback (nano::transaction const & transaction_a, nano::block_hash const & block_a)
 {
-	std::vector<nano::block_hash> rollback_list;
+	std::vector<std::shared_ptr<nano::block>> rollback_list;
 	return rollback (transaction_a, block_a, rollback_list);
 }
 

nano/secure/ledger.hpp

@@ -41,7 +41,7 @@ class ledger final
 	nano::block_hash block_destination (nano::transaction const &, nano::block const &);
 	nano::block_hash block_source (nano::transaction const &, nano::block const &);
 	nano::process_return process (nano::transaction const &, nano::block const &, nano::signature_verification = nano::signature_verification::unknown);
-	bool rollback (nano::transaction const &, nano::block_hash const &, std::vector<nano::block_hash> &);
+	bool rollback (nano::transaction const &, nano::block_hash const &, std::vector<std::shared_ptr<nano::block>> &);
 	bool rollback (nano::transaction const &, nano::block_hash const &);
 	void change_latest (nano::transaction const &, nano::account const &, nano::block_hash const &, nano::account const &, nano::uint128_union const &, uint64_t, bool = false, nano::epoch = nano::epoch::epoch_0);
 	void dump_account_chain (nano::account const &);

nano/slow_test/node.cpp

@@ -11,7 +11,10 @@ using namespace std::chrono_literals;
 
 TEST (system, generate_mass_activity)
 {
-	nano::system system (24000, 1);
+	nano::system system;
+	nano::node_config node_config (24000, system.logging);
+	node_config.enable_voting = false; // Prevent blocks cementing
+	auto node = system.add_node (node_config);
 	system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv);
 	uint32_t count (20);
 	system.generate_mass_activity (count, *system.nodes[0]);
@@ -25,7 +28,11 @@ TEST (system, generate_mass_activity)
 
 TEST (system, generate_mass_activity_long)
 {
-	nano::system system (24000, 1);
+	nano::system system;
+	nano::node_config node_config (24000, system.logging);
+	node_config.enable_voting = false; // Prevent blocks cementing
+	auto node = system.add_node (node_config);
+	system.wallet (0)->wallets.watcher.stop (); // Stop work watcher
 	nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
 	system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv);
 	uint32_t count (1000000000);
@@ -44,7 +51,10 @@ TEST (system, receive_while_synchronizing)
 {
 	std::vector<boost::thread> threads;
 	{
-		nano::system system (24000, 1);
+		nano::system system;
+		nano::node_config node_config (24000, system.logging);
+		node_config.enable_voting = false; // Prevent blocks cementing
+		auto node = system.add_node (node_config);
 		nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
 		system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv);
 		uint32_t count (1000);
@@ -56,6 +66,7 @@ TEST (system, receive_while_synchronizing)
 		auto channel (std::make_shared<nano::transport::channel_udp> (node1->network.udp_channels, system.nodes[0]->network.endpoint ()));
 		node1->network.send_keepalive (channel);
 		auto wallet (node1->wallets.create (1));
+		wallet->insert_adhoc (nano::test_genesis_key.prv); // For voting
 		ASSERT_EQ (key.pub, wallet->insert_adhoc (key.prv));
 		node1->start ();
 		system.nodes.push_back (node1);
@@ -91,21 +102,22 @@ TEST (ledger, deep_account_compute)
 	nano::genesis genesis;
 	auto transaction (store.tx_begin_write ());
 	store.initialize (transaction, genesis);
+	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::keypair key;
 	auto balance (nano::genesis_amount - 1);
-	nano::send_block send (genesis.hash (), key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0);
+	nano::send_block send (genesis.hash (), key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
-	nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, 0);
+	nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, pool.generate (key.pub));
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code);
 	auto sprevious (send.hash ());
 	auto rprevious (open.hash ());
 	for (auto i (0), n (100000); i != n; ++i)
 	{
 		balance -= 1;
-		nano::send_block send (sprevious, key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0);
+		nano::send_block send (sprevious, key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (sprevious));
 		ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
 		sprevious = send.hash ();
-		nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, 0);
+		nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, pool.generate (rprevious));
 		ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code);
 		rprevious = receive.hash ();
 		if (i % 100 == 0)
@@ -177,6 +189,7 @@ TEST (store, load)
 	}
 }
 
+// ulimit -n increasing may be required
 TEST (node, fork_storm)
 {
 	nano::system system (24000, 64);
@@ -189,6 +202,7 @@ TEST (node, fork_storm)
 		balance -= 1;
 		nano::keypair key;
 		nano::send_block send (previous, key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0);
+		system.nodes[j]->work_generate_blocking (send);
 		previous = send.hash ();
 		for (auto i (0); i != system.nodes.size (); ++i)
 		{
@@ -219,6 +233,7 @@ TEST (node, fork_storm)
 			}
 			else
 			{
+				std::lock_guard<std::mutex> lock (node_a->active.mutex);
 				if (node_a->active.roots.begin ()->election->last_votes_size () == 1)
 				{
 					++single;