dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

rename class to

Browse source
This commit is contained in:
gr0vity-dev 2024-05-06 16:11:34 +02:00
commit 4a00f05a75
59 changed files with 195 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

2
nano/core_test/CMakeLists.txt
View file

@ -3,7 +3,7 @@ add_executable(
entry.cpp entry.cpp
fakes/websocket_client.hpp fakes/websocket_client.hpp
fakes/work_peer.hpp fakes/work_peer.hpp
active_transactions.cpp active_elections.cpp
async.cpp async.cpp
backlog.cpp backlog.cpp
block.cpp block.cpp

60
nano/core_test/active_transactions.cpp → nano/core_test/active_elections.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/jsonconfig.hpp> #include <nano/lib/jsonconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
@ -29,7 +29,7 @@ using namespace std::chrono_literals;
* - node2 with: * - node2 with:
* - disabled rep crawler -> this inhibits node2 from learning that node1 is a rep * - disabled rep crawler -> this inhibits node2 from learning that node1 is a rep
*/ */
TEST (active_transactions, confirm_election_by_request) TEST (active_elections, confirm_election_by_request)
{ {
nano::test::system system{}; nano::test::system system{};
auto & node1 = *system.add_node (); auto & node1 = *system.add_node ();
@ -99,7 +99,7 @@ TEST (active_transactions, confirm_election_by_request)
ASSERT_TIMELY (5s, nano::test::confirmed (node2, { send1 })); ASSERT_TIMELY (5s, nano::test::confirmed (node2, { send1 }));
} }
TEST (active_transactions, confirm_frontier) TEST (active_elections, confirm_frontier)
{ {
nano::test::system system; nano::test::system system;
@ -156,14 +156,14 @@ TEST (active_transactions, confirm_frontier)
ASSERT_GT (election2->confirmation_request_count, 0u); ASSERT_GT (election2->confirmation_request_count, 0u);
} }
TEST (active_transactions, keep_local) TEST (active_elections, keep_local)
{ {
nano::test::system system{}; nano::test::system system{};
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
node_config.enable_voting = false; node_config.enable_voting = false;
// Bound to 2, won't drop wallet created transactions, but good to test dropping remote // Bound to 2, won't drop wallet created transactions, but good to test dropping remote
node_config.active_transactions.size = 2; node_config.active_elections.size = 2;
// Disable frontier confirmation to allow the test to finish before // Disable frontier confirmation to allow the test to finish before
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
@ -234,7 +234,7 @@ TEST (active_transactions, keep_local)
node.process_active (receive3); node.process_active (receive3);
/// bound elections, should drop after one loop /// bound elections, should drop after one loop
ASSERT_TIMELY_EQ (5s, node.active.size (), node_config.active_transactions.size); ASSERT_TIMELY_EQ (5s, node.active.size (), node_config.active_elections.size);
// ASSERT_EQ (1, node.scheduler.size ()); // ASSERT_EQ (1, node.scheduler.size ());
} }
@ -543,7 +543,7 @@ TEST (inactive_votes_cache, election_start)
namespace nano namespace nano
{ {
TEST (active_transactions, vote_replays) TEST (active_elections, vote_replays)
{ {
nano::test::system system; nano::test::system system;
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
@ -643,7 +643,7 @@ TEST (active_transactions, vote_replays)
} }
// Tests that blocks are correctly cleared from the duplicate filter for unconfirmed elections // Tests that blocks are correctly cleared from the duplicate filter for unconfirmed elections
TEST (active_transactions, dropped_cleanup) TEST (active_elections, dropped_cleanup)
{ {
nano::test::system system; nano::test::system system;
nano::node_flags flags; nano::node_flags flags;
@ -700,7 +700,7 @@ TEST (active_transactions, dropped_cleanup)
ASSERT_FALSE (node.active.active (hash)); ASSERT_FALSE (node.active.active (hash));
} }
TEST (active_transactions, republish_winner) TEST (active_elections, republish_winner)
{ {
nano::test::system system; nano::test::system system;
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
@ -765,7 +765,7 @@ TEST (active_transactions, republish_winner)
ASSERT_TIMELY (5s, node2.block_confirmed (fork->hash ())); ASSERT_TIMELY (5s, node2.block_confirmed (fork->hash ()));
} }
TEST (active_transactions, fork_filter_cleanup) TEST (active_elections, fork_filter_cleanup)
{ {
nano::test::system system{}; nano::test::system system{};
@ -847,7 +847,7 @@ TEST (active_transactions, fork_filter_cleanup)
* (9 votes from this batch should survive and replace existing blocks in the election, why not 10?) * (9 votes from this batch should survive and replace existing blocks in the election, why not 10?)
* Then send winning block and it should replace one of the existing blocks * Then send winning block and it should replace one of the existing blocks
*/ */
TEST (active_transactions, fork_replacement_tally) TEST (active_elections, fork_replacement_tally)
{ {
nano::test::system system; nano::test::system system;
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
@ -1004,7 +1004,7 @@ TEST (active_transactions, fork_replacement_tally)
namespace nano namespace nano
{ {
// Blocks that won an election must always be seen as confirming or cemented // Blocks that won an election must always be seen as confirming or cemented
TEST (active_transactions, confirmation_consistency) TEST (active_elections, confirmation_consistency)
{ {
nano::test::system system; nano::test::system system;
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
@ -1031,7 +1031,7 @@ TEST (active_transactions, confirmation_consistency)
} }
} }
TEST (active_transactions, confirm_new) TEST (active_elections, confirm_new)
{ {
nano::test::system system (1); nano::test::system system (1);
auto & node1 = *system.nodes[0]; auto & node1 = *system.nodes[0];
@ -1056,7 +1056,7 @@ TEST (active_transactions, confirm_new)
} }
// Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache
TEST (active_transactions, conflicting_block_vote_existing_election) TEST (active_elections, conflicting_block_vote_existing_election)
{ {
nano::test::system system; nano::test::system system;
nano::node_flags node_flags; nano::node_flags node_flags;
@ -1099,7 +1099,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
ASSERT_TIMELY (3s, election->confirmed ()); ASSERT_TIMELY (3s, election->confirmed ());
} }
TEST (active_transactions, activate_account_chain) TEST (active_elections, activate_account_chain)
{ {
nano::test::system system; nano::test::system system;
nano::node_flags flags; nano::node_flags flags;
@ -1199,7 +1199,7 @@ TEST (active_transactions, activate_account_chain)
ASSERT_TIMELY (3s, node.active.active (receive->qualified_root ())); ASSERT_TIMELY (3s, node.active.active (receive->qualified_root ()));
} }
TEST (active_transactions, activate_inactive) TEST (active_elections, activate_inactive)
{ {
nano::test::system system; nano::test::system system;
nano::node_flags flags; nano::node_flags flags;
@ -1257,7 +1257,7 @@ TEST (active_transactions, activate_inactive)
ASSERT_FALSE (node.active.active (open->qualified_root ()) || node.block_confirmed_or_being_confirmed (open->hash ())); ASSERT_FALSE (node.active.active (open->qualified_root ()) || node.block_confirmed_or_being_confirmed (open->hash ()));
} }
TEST (active_transactions, list_active) TEST (active_elections, list_active)
{ {
nano::test::system system (1); nano::test::system system (1);
auto & node = *system.nodes[0]; auto & node = *system.nodes[0];
@ -1312,13 +1312,13 @@ TEST (active_transactions, list_active)
auto active = node.active.list_active (); auto active = node.active.list_active ();
} }
TEST (active_transactions, vacancy) TEST (active_elections, vacancy)
{ {
std::atomic<bool> updated = false; std::atomic<bool> updated = false;
{ {
nano::test::system system; nano::test::system system;
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
config.active_transactions.size = 1; config.active_elections.size = 1;
auto & node = *system.add_node (config); auto & node = *system.add_node (config);
nano::state_block_builder builder; nano::state_block_builder builder;
auto send = builder.make_block () auto send = builder.make_block ()
@ -1349,12 +1349,12 @@ TEST (active_transactions, vacancy)
} }
// Ensure transactions in excess of capacity are removed in fifo order // Ensure transactions in excess of capacity are removed in fifo order
TEST (active_transactions, fifo) TEST (active_elections, fifo)
{ {
nano::test::system system{}; nano::test::system system{};
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
config.active_transactions.size = 1; config.active_elections.size = 1;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node = *system.add_node (config); auto & node = *system.add_node (config);
@ -1434,15 +1434,15 @@ TEST (active_transactions, fifo)
/* /*
* Ensures we limit the number of vote hinted elections in AEC * Ensures we limit the number of vote hinted elections in AEC
*/ */
TEST (active_transactions, limit_vote_hinted_elections) TEST (active_elections, limit_vote_hinted_elections)
{ {
nano::test::system system; nano::test::system system;
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
const int aec_limit = 10; const int aec_limit = 10;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
config.optimistic_scheduler.enabled = false; config.optimistic_scheduler.enabled = false;
config.active_transactions.size = aec_limit; config.active_elections.size = aec_limit;
config.active_transactions.hinted_limit_percentage = 10; // Should give us a limit of 1 hinted election config.active_elections.hinted_limit_percentage = 10; // Should give us a limit of 1 hinted election
auto & node = *system.add_node (config); auto & node = *system.add_node (config);
// Setup representatives // Setup representatives
@ -1500,14 +1500,14 @@ TEST (active_transactions, limit_vote_hinted_elections)
/* /*
* Tests that when AEC is running at capacity from normal elections, it is still possible to schedule a limited number of hinted elections * Tests that when AEC is running at capacity from normal elections, it is still possible to schedule a limited number of hinted elections
*/ */
TEST (active_transactions, allow_limited_overflow) TEST (active_elections, allow_limited_overflow)
{ {
nano::test::system system; nano::test::system system;
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
const int aec_limit = 20; const int aec_limit = 20;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
config.active_transactions.size = aec_limit; config.active_elections.size = aec_limit;
config.active_transactions.hinted_limit_percentage = 20; // Should give us a limit of 4 hinted elections config.active_elections.hinted_limit_percentage = 20; // Should give us a limit of 4 hinted elections
auto & node = *system.add_node (config); auto & node = *system.add_node (config);
auto blocks = nano::test::setup_independent_blocks (system, node, aec_limit * 4); auto blocks = nano::test::setup_independent_blocks (system, node, aec_limit * 4);
@ -1549,14 +1549,14 @@ TEST (active_transactions, allow_limited_overflow)
/* /*
* Tests that when hinted elections are present in the AEC, normal scheduler adapts not to exceed the limit of all elections * Tests that when hinted elections are present in the AEC, normal scheduler adapts not to exceed the limit of all elections
*/ */
TEST (active_transactions, allow_limited_overflow_adapt) TEST (active_elections, allow_limited_overflow_adapt)
{ {
nano::test::system system; nano::test::system system;
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
const int aec_limit = 20; const int aec_limit = 20;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
config.active_transactions.size = aec_limit; config.active_elections.size = aec_limit;
config.active_transactions.hinted_limit_percentage = 20; // Should give us a limit of 4 hinted elections config.active_elections.hinted_limit_percentage = 20; // Should give us a limit of 4 hinted elections
auto & node = *system.add_node (config); auto & node = *system.add_node (config);
auto blocks = nano::test::setup_independent_blocks (system, node, aec_limit * 4); auto blocks = nano::test::setup_independent_blocks (system, node, aec_limit * 4);

2
nano/core_test/backlog.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/test_common/chains.hpp> #include <nano/test_common/chains.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp> #include <nano/test_common/testutil.hpp>

4
nano/core_test/blockprocessor.cpp
View file

@ -16,9 +16,9 @@ TEST (block_processor, broadcast_block_on_arrival)
nano::test::system system; nano::test::system system;
nano::node_config config1 = system.default_config (); nano::node_config config1 = system.default_config ();
// Deactivates elections on both nodes. // Deactivates elections on both nodes.
config1.active_transactions.size = 0; config1.active_elections.size = 0;
nano::node_config config2 = system.default_config (); nano::node_config config2 = system.default_config ();
config2.active_transactions.size = 0; config2.active_elections.size = 0;
nano::node_flags flags; nano::node_flags flags;
// Disables bootstrap listener to make sure the block won't be shared by this channel. // Disables bootstrap listener to make sure the block won't be shared by this channel.
flags.disable_bootstrap_listener = true; flags.disable_bootstrap_listener = true;

2
nano/core_test/bootstrap.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/bootstrap/block_deserializer.hpp> #include <nano/node/bootstrap/block_deserializer.hpp>
#include <nano/node/bootstrap/bootstrap_frontier.hpp> #include <nano/node/bootstrap/bootstrap_frontier.hpp>
#include <nano/node/bootstrap/bootstrap_lazy.hpp> #include <nano/node/bootstrap/bootstrap_lazy.hpp>

2
nano/core_test/confirmation_solicitor.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/jsonconfig.hpp> #include <nano/lib/jsonconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirmation_solicitor.hpp> #include <nano/node/confirmation_solicitor.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/transport/inproc.hpp> #include <nano/node/transport/inproc.hpp>

2
nano/core_test/confirming_set.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/make_store.hpp> #include <nano/node/make_store.hpp>

2
nano/core_test/conflicts.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
#include <nano/node/scheduler/priority.hpp> #include <nano/node/scheduler/priority.hpp>

2
nano/core_test/election.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
#include <nano/node/scheduler/priority.hpp> #include <nano/node/scheduler/priority.hpp>

6
nano/core_test/election_scheduler.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
#include <nano/node/scheduler/priority.hpp> #include <nano/node/scheduler/priority.hpp>
@ -56,7 +56,7 @@ TEST (election_scheduler, activate_one_flush)
/** /**
* Tests that the election scheduler and the active transactions container (AEC) * Tests that the election scheduler and the active transactions container (AEC)
* work in sync with regards to the node configuration value "active_transactions.size". * work in sync with regards to the node configuration value "active_elections.size".
* *
* The test sets up two forcefully cemented blocks -- a send on the genesis account and a receive on a second account. * The test sets up two forcefully cemented blocks -- a send on the genesis account and a receive on a second account.
* It then creates two other blocks, each a successor to one of the previous two, * It then creates two other blocks, each a successor to one of the previous two,
@ -74,7 +74,7 @@ TEST (election_scheduler, no_vacancy)
nano::test::system system{}; nano::test::system system{};
nano::node_config config = system.default_config (); nano::node_config config = system.default_config ();
config.active_transactions.size = 1; config.active_elections.size = 1;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node = *system.add_node (config); auto & node = *system.add_node (config);

2
nano/core_test/frontiers_confirmation.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp> #include <nano/test_common/testutil.hpp>

2
nano/core_test/ledger.cpp
View file

@ -4,7 +4,7 @@
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/lib/threading.hpp> #include <nano/lib/threading.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/make_store.hpp> #include <nano/node/make_store.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>

2
nano/core_test/ledger_confirm.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/make_store.hpp> #include <nano/node/make_store.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>

2
nano/core_test/memory_pool.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/memory.hpp> #include <nano/lib/memory.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/secure/common.hpp> #include <nano/secure/common.hpp>
#include <gtest/gtest.h> #include <gtest/gtest.h>

2
nano/core_test/node.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/config.hpp> #include <nano/lib/config.hpp>
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/inactive_node.hpp> #include <nano/node/inactive_node.hpp>

2
nano/core_test/optimistic_scheduler.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/test_common/chains.hpp> #include <nano/test_common/chains.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>

2
nano/core_test/rep_crawler.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/config.hpp> #include <nano/lib/config.hpp>
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/repcrawler.hpp> #include <nano/node/repcrawler.hpp>
#include <nano/node/transport/fake.hpp> #include <nano/node/transport/fake.hpp>
#include <nano/node/transport/inproc.hpp> #include <nano/node/transport/inproc.hpp>

2
nano/core_test/request_aggregator.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/jsonconfig.hpp> #include <nano/lib/jsonconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/local_vote_history.hpp> #include <nano/node/local_vote_history.hpp>

14
nano/core_test/toml.cpp
View file

@ -152,7 +152,7 @@ TEST (toml, daemon_config_deserialize_defaults)
ASSERT_EQ (conf.rpc.child_process.enable, defaults.rpc.child_process.enable); ASSERT_EQ (conf.rpc.child_process.enable, defaults.rpc.child_process.enable);
ASSERT_EQ (conf.rpc.child_process.rpc_path, defaults.rpc.child_process.rpc_path); ASSERT_EQ (conf.rpc.child_process.rpc_path, defaults.rpc.child_process.rpc_path);
ASSERT_EQ (conf.node.active_transactions.size, defaults.node.active_transactions.size); ASSERT_EQ (conf.node.active_elections.size, defaults.node.active_elections.size);
ASSERT_EQ (conf.node.allow_local_peers, defaults.node.allow_local_peers); ASSERT_EQ (conf.node.allow_local_peers, defaults.node.allow_local_peers);
ASSERT_EQ (conf.node.backup_before_upgrade, defaults.node.backup_before_upgrade); ASSERT_EQ (conf.node.backup_before_upgrade, defaults.node.backup_before_upgrade);
ASSERT_EQ (conf.node.bandwidth_limit, defaults.node.bandwidth_limit); ASSERT_EQ (conf.node.bandwidth_limit, defaults.node.bandwidth_limit);
@ -451,7 +451,7 @@ TEST (toml, daemon_config_deserialize_no_defaults)
priority_bootstrap = 999 priority_bootstrap = 999
priority_local = 999 priority_local = 999
[node.active_transactions] [node.active_elections]
size = 999 size = 999
hinted_limit_percentage = 90 hinted_limit_percentage = 90
optimistic_limit_percentage = 90 optimistic_limit_percentage = 90
@ -607,7 +607,7 @@ TEST (toml, daemon_config_deserialize_no_defaults)
ASSERT_NE (conf.rpc.child_process.enable, defaults.rpc.child_process.enable); ASSERT_NE (conf.rpc.child_process.enable, defaults.rpc.child_process.enable);
ASSERT_NE (conf.rpc.child_process.rpc_path, defaults.rpc.child_process.rpc_path); ASSERT_NE (conf.rpc.child_process.rpc_path, defaults.rpc.child_process.rpc_path);
ASSERT_NE (conf.node.active_transactions.size, defaults.node.active_transactions.size); ASSERT_NE (conf.node.active_elections.size, defaults.node.active_elections.size);
ASSERT_NE (conf.node.allow_local_peers, defaults.node.allow_local_peers); ASSERT_NE (conf.node.allow_local_peers, defaults.node.allow_local_peers);
ASSERT_NE (conf.node.backup_before_upgrade, defaults.node.backup_before_upgrade); ASSERT_NE (conf.node.backup_before_upgrade, defaults.node.backup_before_upgrade);
ASSERT_NE (conf.node.bandwidth_limit, defaults.node.bandwidth_limit); ASSERT_NE (conf.node.bandwidth_limit, defaults.node.bandwidth_limit);
@ -1024,7 +1024,7 @@ TEST (toml, log_config_no_defaults)
rotation_count = 999 rotation_count = 999
[log.levels] [log.levels]
active_transactions = "trace" active_elections = "trace"
blockprocessor = "trace" blockprocessor = "trace"
)toml"; )toml";
@ -1081,7 +1081,7 @@ TEST (toml, merge_config_files)
ss << R"toml( ss << R"toml(
[node] [node]
active_transactions.size = 999 active_elections.size = 999
# backlog_scan_batch_size = 7777 # backlog_scan_batch_size = 7777
[node.bootstrap_ascending] [node.bootstrap_ascending]
block_wait_count = 33333 block_wait_count = 33333
@ -1104,8 +1104,8 @@ TEST (toml, merge_config_files)
merged_toml.read (ss2); merged_toml.read (ss2);
merged_config.deserialize_toml (merged_toml); merged_config.deserialize_toml (merged_toml);
ASSERT_NE (merged_config.node.active_transactions.size, default_config.node.active_transactions.size); ASSERT_NE (merged_config.node.active_elections.size, default_config.node.active_elections.size);
ASSERT_EQ (merged_config.node.active_transactions.size, 999); ASSERT_EQ (merged_config.node.active_elections.size, 999);
ASSERT_NE (merged_config.node.backlog_scan_batch_size, 7777); ASSERT_NE (merged_config.node.backlog_scan_batch_size, 7777);
ASSERT_EQ (merged_config.node.bootstrap_ascending.block_wait_count, 33333); ASSERT_EQ (merged_config.node.bootstrap_ascending.block_wait_count, 33333);
ASSERT_TRUE (merged_config_string.find ("old_entry") == std::string::npos); ASSERT_TRUE (merged_config_string.find ("old_entry") == std::string::npos);

2
nano/core_test/vote_processor.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/jsonconfig.hpp> #include <nano/lib/jsonconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/transport/inproc.hpp> #include <nano/node/transport/inproc.hpp>
#include <nano/node/vote_processor.hpp> #include <nano/node/vote_processor.hpp>

4
nano/core_test/voting.cpp
View file

@ -146,7 +146,7 @@ TEST (vote_spacing, vote_generator)
{ {
nano::node_config config; nano::node_config config;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
config.active_transactions.hinted_limit_percentage = 0; // Disable election hinting config.active_elections.hinted_limit_percentage = 0; // Disable election hinting
nano::test::system system; nano::test::system system;
nano::node_flags node_flags; nano::node_flags node_flags;
node_flags.disable_search_pending = true; node_flags.disable_search_pending = true;
@ -190,7 +190,7 @@ TEST (vote_spacing, rapid)
{ {
nano::node_config config; nano::node_config config;
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
config.active_transactions.hinted_limit_percentage = 0; // Disable election hinting config.active_elections.hinted_limit_percentage = 0; // Disable election hinting
nano::test::system system; nano::test::system system;
nano::node_flags node_flags; nano::node_flags node_flags;
node_flags.disable_search_pending = true; node_flags.disable_search_pending = true;

2
nano/core_test/wallet.cpp
View file

@ -1,7 +1,7 @@
#include <nano/crypto_lib/random_pool.hpp> #include <nano/crypto_lib/random_pool.hpp>
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>
#include <nano/secure/ledger_set_any.hpp> #include <nano/secure/ledger_set_any.hpp>

2
nano/core_test/wallets.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/inactive_node.hpp> #include <nano/node/inactive_node.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>

2
nano/core_test/websocket.cpp
View file

@ -1,6 +1,6 @@
#include <nano/core_test/fakes/websocket_client.hpp> #include <nano/core_test/fakes/websocket_client.hpp>
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/transport/fake.hpp> #include <nano/node/transport/fake.hpp>
#include <nano/node/websocket.hpp> #include <nano/node/websocket.hpp>
#include <nano/test_common/network.hpp> #include <nano/test_common/network.hpp>

4
nano/lib/logging_enums.hpp
View file

@ -45,7 +45,7 @@ enum class type
ipc_server, ipc_server,
websocket, websocket,
tls, tls,
active_transactions, active_elections,
election, election,
blockprocessor, blockprocessor,
network, network,
@ -104,7 +104,7 @@ enum class detail
// node // node
process_confirmed, process_confirmed,
// active_transactions // active_elections
active_started, active_started,
active_stopped, active_stopped,

2
nano/lib/stats_enums.hpp
View file

@ -55,7 +55,7 @@ enum class type
bootstrap_server_overfill, bootstrap_server_overfill,
bootstrap_server_response, bootstrap_server_response,
active, active,
active_transactions, active_elections,
active_started, active_started,
active_confirmed, active_confirmed,
active_dropped, active_dropped,

4
nano/nano_node/entry.cpp
View file

@ -4,7 +4,7 @@
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/lib/utility.hpp> #include <nano/lib/utility.hpp>
#include <nano/nano_node/daemon.hpp> #include <nano/nano_node/daemon.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/cli.hpp> #include <nano/node/cli.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/daemonconfig.hpp> #include <nano/node/daemonconfig.hpp>
@ -1238,7 +1238,7 @@ int main (int argc, char * const * argv)
else else
{ {
config2.frontiers_confirmation = daemon_config.node.frontiers_confirmation; config2.frontiers_confirmation = daemon_config.node.frontiers_confirmation;
config2.active_transactions.size = daemon_config.node.active_transactions.size; config2.active_elections.size = daemon_config.node.active_elections.size;
} }
auto node2 (std::make_shared<nano::node> (io_ctx2, path2, config2, work, flags, 1)); auto node2 (std::make_shared<nano::node> (io_ctx2, path2, config2, work, flags, 1));

4
nano/node/CMakeLists.txt
View file

@ -14,8 +14,8 @@ endif()
add_library( add_library(
node node
${platform_sources} ${platform_sources}
active_transactions.hpp active_elections.hpp
active_transactions.cpp active_elections.cpp
backlog_population.hpp backlog_population.hpp
backlog_population.cpp backlog_population.cpp
bandwidth_limiter.hpp bandwidth_limiter.hpp

114
nano/node/active_transactions.cpp → nano/node/active_elections.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/numbers.hpp> #include <nano/lib/numbers.hpp>
#include <nano/lib/threading.hpp> #include <nano/lib/threading.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirmation_solicitor.hpp> #include <nano/node/confirmation_solicitor.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
@ -17,8 +17,8 @@
using namespace std::chrono; using namespace std::chrono;
nano::active_transactions::active_transactions (nano::node & node_a, nano::confirming_set & confirming_set, nano::block_processor & block_processor_a) : nano::active_elections::active_elections (nano::node & node_a, nano::confirming_set & confirming_set, nano::block_processor & block_processor_a) :
config{ node_a.config.active_transactions }, config{ node_a.config.active_elections },
node{ node_a }, node{ node_a },
confirming_set{ confirming_set }, confirming_set{ confirming_set },
block_processor{ block_processor_a }, block_processor{ block_processor_a },
@ -51,13 +51,13 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi
}); });
} }
nano::active_transactions::~active_transactions () nano::active_elections::~active_elections ()
{ {
// Thread must be stopped before destruction // Thread must be stopped before destruction
debug_assert (!thread.joinable ()); debug_assert (!thread.joinable ());
} }
void nano::active_transactions::start () void nano::active_elections::start ()
{ {
if (node.flags.disable_request_loop) if (node.flags.disable_request_loop)
{ {
@ -72,7 +72,7 @@ void nano::active_transactions::start ()
}); });
} }
void nano::active_transactions::stop () void nano::active_elections::stop ()
{ {
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
@ -83,7 +83,7 @@ void nano::active_transactions::stop ()
clear (); clear ();
} }
void nano::active_transactions::block_cemented_callback (std::shared_ptr<nano::block> const & block) void nano::active_elections::block_cemented_callback (std::shared_ptr<nano::block> const & block)
{ {
debug_assert (node.block_confirmed (block->hash ())); debug_assert (node.block_confirmed (block->hash ()));
if (auto election_l = election (block->qualified_root ())) if (auto election_l = election (block->qualified_root ()))
@ -124,7 +124,7 @@ void nano::active_transactions::block_cemented_callback (std::shared_ptr<nano::b
} }
} }
void nano::active_transactions::notify_observers (nano::secure::read_transaction const & transaction, nano::election_status const & status, std::vector<nano::vote_with_weight_info> const & votes) void nano::active_elections::notify_observers (nano::secure::read_transaction const & transaction, nano::election_status const & status, std::vector<nano::vote_with_weight_info> const & votes)
{ {
auto block = status.winner; auto block = status.winner;
auto account = block->account (); auto account = block->account ();
@ -143,7 +143,7 @@ void nano::active_transactions::notify_observers (nano::secure::read_transaction
} }
} }
void nano::active_transactions::activate_successors (nano::secure::read_transaction const & transaction, std::shared_ptr<nano::block> const & block) void nano::active_elections::activate_successors (nano::secure::read_transaction const & transaction, std::shared_ptr<nano::block> const & block)
{ {
node.scheduler.priority.activate (transaction, block->account ()); node.scheduler.priority.activate (transaction, block->account ());
@ -154,13 +154,13 @@ void nano::active_transactions::activate_successors (nano::secure::read_transact
} }
} }
void nano::active_transactions::add_election_winner_details (nano::block_hash const & hash_a, std::shared_ptr<nano::election> const & election_a) void nano::active_elections::add_election_winner_details (nano::block_hash const & hash_a, std::shared_ptr<nano::election> const & election_a)
{ {
nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex }; nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex };
election_winner_details.emplace (hash_a, election_a); election_winner_details.emplace (hash_a, election_a);
} }
std::shared_ptr<nano::election> nano::active_transactions::remove_election_winner_details (nano::block_hash const & hash_a) std::shared_ptr<nano::election> nano::active_elections::remove_election_winner_details (nano::block_hash const & hash_a)
{ {
nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex }; nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex };
std::shared_ptr<nano::election> result; std::shared_ptr<nano::election> result;
@ -173,7 +173,7 @@ std::shared_ptr<nano::election> nano::active_transactions::remove_election_winne
return result; return result;
} }
void nano::active_transactions::block_already_cemented_callback (nano::block_hash const & hash_a) void nano::active_elections::block_already_cemented_callback (nano::block_hash const & hash_a)
{ {
// Depending on timing there is a situation where the election_winner_details is not reset. // Depending on timing there is a situation where the election_winner_details is not reset.
// This can happen when a block wins an election, and the block is confirmed + observer // This can happen when a block wins an election, and the block is confirmed + observer
@ -182,7 +182,7 @@ void nano::active_transactions::block_already_cemented_callback (nano::block_has
remove_election_winner_details (hash_a); remove_election_winner_details (hash_a);
} }
int64_t nano::active_transactions::limit (nano::election_behavior behavior) const int64_t nano::active_elections::limit (nano::election_behavior behavior) const
{ {
switch (behavior) switch (behavior)
{ {
@ -206,7 +206,7 @@ int64_t nano::active_transactions::limit (nano::election_behavior behavior) cons
return 0; return 0;
} }
int64_t nano::active_transactions::vacancy (nano::election_behavior behavior) const int64_t nano::active_elections::vacancy (nano::election_behavior behavior) const
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
switch (behavior) switch (behavior)
@ -221,7 +221,7 @@ int64_t nano::active_transactions::vacancy (nano::election_behavior behavior) co
return 0; return 0;
} }
void nano::active_transactions::request_confirm (nano::unique_lock<nano::mutex> & lock_a) void nano::active_elections::request_confirm (nano::unique_lock<nano::mutex> & lock_a)
{ {
debug_assert (lock_a.owns_lock ()); debug_assert (lock_a.owns_lock ());
@ -258,7 +258,7 @@ void nano::active_transactions::request_confirm (nano::unique_lock<nano::mutex>
lock_a.lock (); lock_a.lock ();
} }
void nano::active_transactions::cleanup_election (nano::unique_lock<nano::mutex> & lock_a, std::shared_ptr<nano::election> election) void nano::active_elections::cleanup_election (nano::unique_lock<nano::mutex> & lock_a, std::shared_ptr<nano::election> election)
{ {
debug_assert (!mutex.try_lock ()); debug_assert (!mutex.try_lock ());
debug_assert (lock_a.owns_lock ()); debug_assert (lock_a.owns_lock ());
@ -279,9 +279,9 @@ void nano::active_transactions::cleanup_election (nano::unique_lock<nano::mutex>
roots.get<tag_root> ().erase (roots.get<tag_root> ().find (election->qualified_root)); roots.get<tag_root> ().erase (roots.get<tag_root> ().find (election->qualified_root));
node.stats.inc (completion_type (*election), to_stat_detail (election->behavior ())); node.stats.inc (completion_type (*election), to_stat_detail (election->behavior ()));
node.logger.trace (nano::log::type::active_transactions, nano::log::detail::active_stopped, nano::log::arg{ "election", election }); node.logger.trace (nano::log::type::active_elections, nano::log::detail::active_stopped, nano::log::arg{ "election", election });
node.logger.debug (nano::log::type::active_transactions, "Erased election for blocks: {} (behavior: {}, state: {})", node.logger.debug (nano::log::type::active_elections, "Erased election for blocks: {} (behavior: {}, state: {})",
fmt::join (std::views::keys (blocks_l), ", "), fmt::join (std::views::keys (blocks_l), ", "),
to_string (election->behavior ()), to_string (election->behavior ()),
to_string (election->state ())); to_string (election->state ()));
@ -308,7 +308,7 @@ void nano::active_transactions::cleanup_election (nano::unique_lock<nano::mutex>
} }
} }
nano::stat::type nano::active_transactions::completion_type (nano::election const & election) const nano::stat::type nano::active_elections::completion_type (nano::election const & election) const
{ {
if (election.confirmed ()) if (election.confirmed ())
{ {
@ -321,13 +321,13 @@ nano::stat::type nano::active_transactions::completion_type (nano::election cons
return nano::stat::type::active_dropped; return nano::stat::type::active_dropped;
} }
std::vector<std::shared_ptr<nano::election>> nano::active_transactions::list_active (std::size_t max_a) std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active (std::size_t max_a)
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
return list_active_impl (max_a); return list_active_impl (max_a);
} }
std::vector<std::shared_ptr<nano::election>> nano::active_transactions::list_active_impl (std::size_t max_a) const std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active_impl (std::size_t max_a) const
{ {
std::vector<std::shared_ptr<nano::election>> result_l; std::vector<std::shared_ptr<nano::election>> result_l;
result_l.reserve (std::min (max_a, roots.size ())); result_l.reserve (std::min (max_a, roots.size ()));
@ -342,7 +342,7 @@ std::vector<std::shared_ptr<nano::election>> nano::active_transactions::list_act
return result_l; return result_l;
} }
void nano::active_transactions::request_loop () void nano::active_elections::request_loop ()
{ {
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
while (!stopped) while (!stopped)
@ -363,7 +363,7 @@ void nano::active_transactions::request_loop ()
} }
} }
void nano::active_transactions::trim () void nano::active_elections::trim ()
{ {
/* /*
* Both normal and hinted election schedulers are well-behaved, meaning they first check for AEC vacancy before inserting new elections. * Both normal and hinted election schedulers are well-behaved, meaning they first check for AEC vacancy before inserting new elections.
@ -377,7 +377,7 @@ void nano::active_transactions::trim ()
} }
} }
nano::election_insertion_result nano::active_transactions::insert (std::shared_ptr<nano::block> const & block_a, nano::election_behavior election_behavior_a) nano::election_insertion_result nano::active_elections::insert (std::shared_ptr<nano::block> const & block_a, nano::election_behavior election_behavior_a)
{ {
debug_assert (block_a); debug_assert (block_a);
debug_assert (block_a->has_sideband ()); debug_assert (block_a->has_sideband ());
@ -404,7 +404,7 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p
node.online_reps.observe (rep_a); node.online_reps.observe (rep_a);
}; };
result.election = nano::make_shared<nano::election> (node, block_a, nullptr, observe_rep_cb, election_behavior_a); result.election = nano::make_shared<nano::election> (node, block_a, nullptr, observe_rep_cb, election_behavior_a);
roots.get<tag_root> ().emplace (nano::active_transactions::conflict_info{ root, result.election }); roots.get<tag_root> ().emplace (nano::active_elections::conflict_info{ root, result.election });
blocks.emplace (hash, result.election); blocks.emplace (hash, result.election);
// Keep track of election count by election type // Keep track of election count by election type
@ -412,11 +412,11 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p
count_by_behavior[result.election->behavior ()]++; count_by_behavior[result.election->behavior ()]++;
node.stats.inc (nano::stat::type::active_started, to_stat_detail (election_behavior_a)); node.stats.inc (nano::stat::type::active_started, to_stat_detail (election_behavior_a));
node.logger.trace (nano::log::type::active_transactions, nano::log::detail::active_started, node.logger.trace (nano::log::type::active_elections, nano::log::detail::active_started,
nano::log::arg{ "behavior", election_behavior_a }, nano::log::arg{ "behavior", election_behavior_a },
nano::log::arg{ "election", result.election }); nano::log::arg{ "election", result.election });
node.logger.debug (nano::log::type::active_transactions, "Started new election for block: {} (behavior: {})", node.logger.debug (nano::log::type::active_elections, "Started new election for block: {} (behavior: {})",
hash.to_string (), hash.to_string (),
to_string (election_behavior_a)); to_string (election_behavior_a));
} }
@ -453,7 +453,7 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p
return result; return result;
} }
bool nano::active_transactions::trigger_vote_cache (nano::block_hash hash) bool nano::active_elections::trigger_vote_cache (nano::block_hash hash)
{ {
auto cached = node.vote_cache.find (hash); auto cached = node.vote_cache.find (hash);
for (auto const & cached_vote : cached) for (auto const & cached_vote : cached)
@ -464,7 +464,7 @@ bool nano::active_transactions::trigger_vote_cache (nano::block_hash hash)
} }
// Validate a vote and apply it to the current election if one exists // Validate a vote and apply it to the current election if one exists
std::unordered_map<nano::block_hash, nano::vote_code> nano::active_transactions::vote (std::shared_ptr<nano::vote> const & vote, nano::vote_source source) std::unordered_map<nano::block_hash, nano::vote_code> nano::active_elections::vote (std::shared_ptr<nano::vote> const & vote, nano::vote_source source)
{ {
debug_assert (!vote->validate ()); // false => valid vote debug_assert (!vote->validate ()); // false => valid vote
@ -513,25 +513,25 @@ std::unordered_map<nano::block_hash, nano::vote_code> nano::active_transactions:
return results; return results;
} }
bool nano::active_transactions::active (nano::qualified_root const & root_a) const bool nano::active_elections::active (nano::qualified_root const & root_a) const
{ {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
return roots.get<tag_root> ().find (root_a) != roots.get<tag_root> ().end (); return roots.get<tag_root> ().find (root_a) != roots.get<tag_root> ().end ();
} }
bool nano::active_transactions::active (nano::block const & block_a) const bool nano::active_elections::active (nano::block const & block_a) const
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
return roots.get<tag_root> ().find (block_a.qualified_root ()) != roots.get<tag_root> ().end () && blocks.find (block_a.hash ()) != blocks.end (); return roots.get<tag_root> ().find (block_a.qualified_root ()) != roots.get<tag_root> ().end () && blocks.find (block_a.hash ()) != blocks.end ();
} }
bool nano::active_transactions::active (const nano::block_hash & hash) const bool nano::active_elections::active (const nano::block_hash & hash) const
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
return blocks.find (hash) != blocks.end (); return blocks.find (hash) != blocks.end ();
} }
std::shared_ptr<nano::election> nano::active_transactions::election (nano::qualified_root const & root_a) const std::shared_ptr<nano::election> nano::active_elections::election (nano::qualified_root const & root_a) const
{ {
std::shared_ptr<nano::election> result; std::shared_ptr<nano::election> result;
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
@ -543,7 +543,7 @@ std::shared_ptr<nano::election> nano::active_transactions::election (nano::quali
return result; return result;
} }
std::shared_ptr<nano::block> nano::active_transactions::winner (nano::block_hash const & hash_a) const std::shared_ptr<nano::block> nano::active_elections::winner (nano::block_hash const & hash_a) const
{ {
std::shared_ptr<nano::block> result; std::shared_ptr<nano::block> result;
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
@ -557,12 +557,12 @@ std::shared_ptr<nano::block> nano::active_transactions::winner (nano::block_hash
return result; return result;
} }
bool nano::active_transactions::erase (nano::block const & block_a) bool nano::active_elections::erase (nano::block const & block_a)
{ {
return erase (block_a.qualified_root ()); return erase (block_a.qualified_root ());
} }
bool nano::active_transactions::erase (nano::qualified_root const & root_a) bool nano::active_elections::erase (nano::qualified_root const & root_a)
{ {
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
auto root_it (roots.get<tag_root> ().find (root_a)); auto root_it (roots.get<tag_root> ().find (root_a));
@ -574,7 +574,7 @@ bool nano::active_transactions::erase (nano::qualified_root const & root_a)
return false; return false;
} }
bool nano::active_transactions::erase_hash (nano::block_hash const & hash_a) bool nano::active_elections::erase_hash (nano::block_hash const & hash_a)
{ {
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
[[maybe_unused]] auto erased (blocks.erase (hash_a)); [[maybe_unused]] auto erased (blocks.erase (hash_a));
@ -582,7 +582,7 @@ bool nano::active_transactions::erase_hash (nano::block_hash const & hash_a)
return erased == 1; return erased == 1;
} }
void nano::active_transactions::erase_oldest () void nano::active_elections::erase_oldest ()
{ {
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
if (!roots.empty ()) if (!roots.empty ())
@ -592,19 +592,19 @@ void nano::active_transactions::erase_oldest ()
} }
} }
bool nano::active_transactions::empty () const bool nano::active_elections::empty () const
{ {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
return roots.empty (); return roots.empty ();
} }
std::size_t nano::active_transactions::size () const std::size_t nano::active_elections::size () const
{ {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
return roots.size (); return roots.size ();
} }
bool nano::active_transactions::publish (std::shared_ptr<nano::block> const & block_a) bool nano::active_elections::publish (std::shared_ptr<nano::block> const & block_a)
{ {
nano::unique_lock<nano::mutex> lock{ mutex }; nano::unique_lock<nano::mutex> lock{ mutex };
auto existing (roots.get<tag_root> ().find (block_a->qualified_root ())); auto existing (roots.get<tag_root> ().find (block_a->qualified_root ()));
@ -628,13 +628,13 @@ bool nano::active_transactions::publish (std::shared_ptr<nano::block> const & bl
return result; return result;
} }
std::size_t nano::active_transactions::election_winner_details_size () std::size_t nano::active_elections::election_winner_details_size ()
{ {
nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex }; nano::lock_guard<nano::mutex> guard{ election_winner_details_mutex };
return election_winner_details.size (); return election_winner_details.size ();
} }
void nano::active_transactions::clear () void nano::active_elections::clear ()
{ {
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
@ -644,20 +644,20 @@ void nano::active_transactions::clear ()
vacancy_update (); vacancy_update ();
} }
std::unique_ptr<nano::container_info_component> nano::collect_container_info (active_transactions & active_transactions, std::string const & name) std::unique_ptr<nano::container_info_component> nano::collect_container_info (active_elections & active_elections, std::string const & name)
{ {
nano::lock_guard<nano::mutex> guard{ active_transactions.mutex }; nano::lock_guard<nano::mutex> guard{ active_elections.mutex };
auto composite = std::make_unique<container_info_composite> (name); auto composite = std::make_unique<container_info_composite> (name);
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "roots", active_transactions.roots.size (), sizeof (decltype (active_transactions.roots)::value_type) })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "roots", active_elections.roots.size (), sizeof (decltype (active_elections.roots)::value_type) }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "blocks", active_transactions.blocks.size (), sizeof (decltype (active_transactions.blocks)::value_type) })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "blocks", active_elections.blocks.size (), sizeof (decltype (active_elections.blocks)::value_type) }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "election_winner_details", active_transactions.election_winner_details_size (), sizeof (decltype (active_transactions.election_winner_details)::value_type) })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "election_winner_details", active_elections.election_winner_details_size (), sizeof (decltype (active_elections.election_winner_details)::value_type) }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "normal", static_cast<std::size_t> (active_transactions.count_by_behavior[nano::election_behavior::normal]), 0 })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "normal", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::normal]), 0 }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "hinted", static_cast<std::size_t> (active_transactions.count_by_behavior[nano::election_behavior::hinted]), 0 })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "hinted", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::hinted]), 0 }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "optimistic", static_cast<std::size_t> (active_transactions.count_by_behavior[nano::election_behavior::optimistic]), 0 })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "optimistic", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::optimistic]), 0 }));
composite->add_component (active_transactions.recently_confirmed.collect_container_info ("recently_confirmed")); composite->add_component (active_elections.recently_confirmed.collect_container_info ("recently_confirmed"));
composite->add_component (active_transactions.recently_cemented.collect_container_info ("recently_cemented")); composite->add_component (active_elections.recently_cemented.collect_container_info ("recently_cemented"));
return composite; return composite;
} }
@ -767,14 +767,14 @@ std::unique_ptr<nano::container_info_component> nano::recently_cemented_cache::c
} }
/* /*
* active_transactions_config * active_elections_config
*/ */
nano::active_transactions_config::active_transactions_config (const nano::network_constants & network_constants) nano::active_elections_config::active_elections_config (const nano::network_constants & network_constants)
{ {
} }
nano::error nano::active_transactions_config::serialize (nano::tomlconfig & toml) const nano::error nano::active_elections_config::serialize (nano::tomlconfig & toml) const
{ {
toml.put ("size", size, "Number of active elections. Elections beyond this limit have limited survival time.\nWarning: modifying this value may result in a lower confirmation rate. \ntype:uint64,[250..]"); toml.put ("size", size, "Number of active elections. Elections beyond this limit have limited survival time.\nWarning: modifying this value may result in a lower confirmation rate. \ntype:uint64,[250..]");
toml.put ("hinted_limit_percentage", hinted_limit_percentage, "Limit of hinted elections as percentage of `active_elections_size` \ntype:uint64"); toml.put ("hinted_limit_percentage", hinted_limit_percentage, "Limit of hinted elections as percentage of `active_elections_size` \ntype:uint64");
@ -785,7 +785,7 @@ nano::error nano::active_transactions_config::serialize (nano::tomlconfig & toml
return toml.get_error (); return toml.get_error ();
} }
nano::error nano::active_transactions_config::deserialize (nano::tomlconfig & toml) nano::error nano::active_elections_config::deserialize (nano::tomlconfig & toml)
{ {
toml.get ("size", size); toml.get ("size", size);
toml.get ("hinted_limit_percentage", hinted_limit_percentage); toml.get ("hinted_limit_percentage", hinted_limit_percentage);

24
nano/node/active_transactions.hpp → nano/node/active_elections.hpp
View file

@ -25,7 +25,7 @@ namespace mi = boost::multi_index;
namespace nano namespace nano
{ {
class node; class node;
class active_transactions; class active_elections;
class block; class block;
class block_sideband; class block_sideband;
class block_processor; class block_processor;
@ -41,10 +41,10 @@ class read_transaction;
namespace nano namespace nano
{ {
class active_transactions_config final class active_elections_config final
{ {
public: public:
explicit active_transactions_config (nano::network_constants const &); explicit active_elections_config (nano::network_constants const &);
nano::error deserialize (nano::tomlconfig & toml); nano::error deserialize (nano::tomlconfig & toml);
nano::error serialize (nano::tomlconfig & toml) const; nano::error serialize (nano::tomlconfig & toml) const;
@ -132,7 +132,7 @@ public: // Container info
* Core class for determining consensus * Core class for determining consensus
* Holds all active blocks i.e. recently added blocks that need confirmation * Holds all active blocks i.e. recently added blocks that need confirmation
*/ */
class active_transactions final class active_elections final
{ {
private: // Elections private: // Elections
class conflict_info final class conflict_info final
@ -163,8 +163,8 @@ private: // Elections
std::unordered_map<nano::block_hash, std::shared_ptr<nano::election>> blocks; std::unordered_map<nano::block_hash, std::shared_ptr<nano::election>> blocks;
public: public:
active_transactions (nano::node &, nano::confirming_set &, nano::block_processor &); active_elections (nano::node &, nano::confirming_set &, nano::block_processor &);
~active_transactions (); ~active_elections ();
void start (); void start ();
void stop (); void stop ();
@ -230,7 +230,7 @@ private:
bool trigger_vote_cache (nano::block_hash); bool trigger_vote_cache (nano::block_hash);
private: // Dependencies private: // Dependencies
active_transactions_config const & config; active_elections_config const & config;
nano::node & node; nano::node & node;
nano::confirming_set & confirming_set; nano::confirming_set & confirming_set;
nano::block_processor & block_processor; nano::block_processor & block_processor;
@ -258,7 +258,7 @@ private:
std::thread thread; std::thread thread;
friend class election; friend class election;
friend std::unique_ptr<container_info_component> collect_container_info (active_transactions &, std::string const &); friend std::unique_ptr<container_info_component> collect_container_info (active_elections &, std::string const &);
public: // Tests public: // Tests
void clear (); void clear ();
@ -266,15 +266,15 @@ public: // Tests
friend class node_fork_storm_Test; friend class node_fork_storm_Test;
friend class system_block_sequence_Test; friend class system_block_sequence_Test;
friend class node_mass_block_new_Test; friend class node_mass_block_new_Test;
friend class active_transactions_vote_replays_Test; friend class active_elections_vote_replays_Test;
friend class frontiers_confirmation_prioritize_frontiers_Test; friend class frontiers_confirmation_prioritize_frontiers_Test;
friend class frontiers_confirmation_prioritize_frontiers_max_optimistic_elections_Test; friend class frontiers_confirmation_prioritize_frontiers_max_optimistic_elections_Test;
friend class confirmation_height_prioritize_frontiers_overwrite_Test; friend class confirmation_height_prioritize_frontiers_overwrite_Test;
friend class active_transactions_confirmation_consistency_Test; friend class active_elections_confirmation_consistency_Test;
friend class node_deferred_dependent_elections_Test; friend class node_deferred_dependent_elections_Test;
friend class active_transactions_pessimistic_elections_Test; friend class active_elections_pessimistic_elections_Test;
friend class frontiers_confirmation_expired_optimistic_elections_removal_Test; friend class frontiers_confirmation_expired_optimistic_elections_removal_Test;
}; };
std::unique_ptr<container_info_component> collect_container_info (active_transactions & active_transactions, std::string const & name); std::unique_ptr<container_info_component> collect_container_info (active_elections & active_elections, std::string const & name);
} }

2
nano/node/blockprocessor.cpp
View file

@ -2,7 +2,7 @@
#include <nano/lib/enum_util.hpp> #include <nano/lib/enum_util.hpp>
#include <nano/lib/threading.hpp> #include <nano/lib/threading.hpp>
#include <nano/lib/timer.hpp> #include <nano/lib/timer.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/blockprocessor.hpp> #include <nano/node/blockprocessor.hpp>
#include <nano/node/local_vote_history.hpp> #include <nano/node/local_vote_history.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>

2
nano/node/cli.cpp
View file

@ -93,7 +93,7 @@ void nano::add_node_flag_options (boost::program_options::options_description &
// clang-format off // clang-format off
description_a.add_options() description_a.add_options()
("disable_add_initial_peers", "Disable contacting the peer in the peers table at startup") ("disable_add_initial_peers", "Disable contacting the peer in the peers table at startup")
("disable_activate_successors", "Disables activate_successors in active_transactions") ("disable_activate_successors", "Disables activate_successors in active_elections")
("disable_backup", "Disable wallet automatic backups") ("disable_backup", "Disable wallet automatic backups")
("disable_lazy_bootstrap", "Disables lazy bootstrap") ("disable_lazy_bootstrap", "Disables lazy bootstrap")
("disable_legacy_bootstrap", "Disables legacy bootstrap") ("disable_legacy_bootstrap", "Disables legacy bootstrap")

2
nano/node/common.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/memory.hpp> #include <nano/lib/memory.hpp>
#include <nano/lib/stream.hpp> #include <nano/lib/stream.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/network.hpp> #include <nano/node/network.hpp>

2
nano/node/election.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/enum_util.hpp> #include <nano/lib/enum_util.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirmation_solicitor.hpp> #include <nano/node/confirmation_solicitor.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/local_vote_history.hpp> #include <nano/node/local_vote_history.hpp>

2
nano/node/election.hpp
View file

@ -181,7 +181,7 @@ public: // Logging
private: // Constants private: // Constants
static std::size_t constexpr max_blocks{ 10 }; static std::size_t constexpr max_blocks{ 10 };
friend class active_transactions; friend class active_elections;
friend class confirmation_solicitor; friend class confirmation_solicitor;
public: // Only used in tests public: // Only used in tests

2
nano/node/inactive_node.cpp
View file

@ -1,4 +1,4 @@
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/inactive_node.hpp> #include <nano/node/inactive_node.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>

4
nano/node/json_handler.cpp
View file

@ -3,7 +3,7 @@
#include <nano/lib/json_error_response.hpp> #include <nano/lib/json_error_response.hpp>
#include <nano/lib/stats_sinks.hpp> #include <nano/lib/stats_sinks.hpp>
#include <nano/lib/timer.hpp> #include <nano/lib/timer.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/bootstrap/bootstrap_lazy.hpp> #include <nano/node/bootstrap/bootstrap_lazy.hpp>
#include <nano/node/bootstrap_ascending/service.hpp> #include <nano/node/bootstrap_ascending/service.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
@ -2039,7 +2039,7 @@ void nano::json_handler::election_statistics ()
} }
} }
auto utilization_percentage = (static_cast<double> (total_count * 100) / node.config.active_transactions.size); auto utilization_percentage = (static_cast<double> (total_count * 100) / node.config.active_elections.size);
auto max_election_age = std::chrono::duration_cast<std::chrono::milliseconds> (now - oldest_election_start).count (); auto max_election_age = std::chrono::duration_cast<std::chrono::milliseconds> (now - oldest_election_start).count ();
auto average_election_age = total_count ? std::chrono::duration_cast<std::chrono::milliseconds> (total_age).count () / total_count : 0; auto average_election_age = total_count ? std::chrono::duration_cast<std::chrono::milliseconds> (total_age).count () / total_count : 0;

4
nano/node/node.cpp
View file

@ -2,7 +2,7 @@
#include <nano/lib/stream.hpp> #include <nano/lib/stream.hpp>
#include <nano/lib/tomlconfig.hpp> #include <nano/lib/tomlconfig.hpp>
#include <nano/lib/utility.hpp> #include <nano/lib/utility.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/daemonconfig.hpp> #include <nano/node/daemonconfig.hpp>
@ -178,7 +178,7 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
block_processor (*this), block_processor (*this),
confirming_set_impl{ std::make_unique<nano::confirming_set> (ledger, config.confirming_set_batch_time) }, confirming_set_impl{ std::make_unique<nano::confirming_set> (ledger, config.confirming_set_batch_time) },
confirming_set{ *confirming_set_impl }, confirming_set{ *confirming_set_impl },
active_impl{ std::make_unique<nano::active_transactions> (*this, confirming_set, block_processor) }, active_impl{ std::make_unique<nano::active_elections> (*this, confirming_set, block_processor) },
active{ *active_impl }, active{ *active_impl },
rep_crawler (config.rep_crawler, *this), rep_crawler (config.rep_crawler, *this),
rep_tiers{ ledger, network_params, online_reps, stats, logger }, rep_tiers{ ledger, network_params, online_reps, stats, logger },

6
nano/node/node.hpp
View file

@ -43,7 +43,7 @@
namespace nano namespace nano
{ {
class active_transactions; class active_elections;
class confirming_set; class confirming_set;
class node; class node;
class vote_processor; class vote_processor;
@ -172,8 +172,8 @@ public:
nano::block_processor block_processor; nano::block_processor block_processor;
std::unique_ptr<nano::confirming_set> confirming_set_impl; std::unique_ptr<nano::confirming_set> confirming_set_impl;
nano::confirming_set & confirming_set; nano::confirming_set & confirming_set;
std::unique_ptr<nano::active_transactions> active_impl; std::unique_ptr<nano::active_elections> active_impl;
nano::active_transactions & active; nano::active_elections & active;
nano::online_reps online_reps; nano::online_reps online_reps;
nano::rep_crawler rep_crawler; nano::rep_crawler rep_crawler;
nano::rep_tiers rep_tiers; nano::rep_tiers rep_tiers;

18
nano/node/nodeconfig.cpp
View file

@ -34,7 +34,7 @@ nano::node_config::node_config (const std::optional<uint16_t> & peering_port_a,
ipc_config{ network_params.network }, ipc_config{ network_params.network },
external_address{ boost::asio::ip::address_v6{}.to_string () }, external_address{ boost::asio::ip::address_v6{}.to_string () },
rep_crawler{ network_params.network }, rep_crawler{ network_params.network },
active_transactions{ network_params.network }, active_elections{ network_params.network },
block_processor{ network_params.network }, block_processor{ network_params.network },
peer_history{ network_params.network }, peer_history{ network_params.network },
tcp{ network_params.network } tcp{ network_params.network }
@ -217,9 +217,9 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const
rep_crawler.serialize (rep_crawler_l); rep_crawler.serialize (rep_crawler_l);
toml.put_child ("rep_crawler", rep_crawler_l); toml.put_child ("rep_crawler", rep_crawler_l);
nano::tomlconfig active_transactions_l; nano::tomlconfig active_elections_l;
active_transactions.serialize (active_transactions_l); active_elections.serialize (active_elections_l);
toml.put_child ("active_transactions", active_transactions_l); toml.put_child ("active_elections", active_elections_l);
nano::tomlconfig block_processor_l; nano::tomlconfig block_processor_l;
block_processor.serialize (block_processor_l); block_processor.serialize (block_processor_l);
@ -314,10 +314,10 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
rep_crawler.deserialize (config_l); rep_crawler.deserialize (config_l);
} }
if (toml.has_key ("active_transactions")) if (toml.has_key ("active_elections"))
{ {
auto config_l = toml.get_required_child ("active_transactions"); auto config_l = toml.get_required_child ("active_elections");
active_transactions.deserialize (config_l); active_elections.deserialize (config_l);
} }
if (toml.has_key ("block_processor")) if (toml.has_key ("block_processor"))
@ -531,9 +531,9 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
{ {
toml.get_error ().set ("io_threads must be non-zero"); toml.get_error ().set ("io_threads must be non-zero");
} }
if (active_transactions.size <= 250 && !network_params.network.is_dev_network ()) if (active_elections.size <= 250 && !network_params.network.is_dev_network ())
{ {
toml.get_error ().set ("active_transactions.size must be greater than 250"); toml.get_error ().set ("active_elections.size must be greater than 250");
} }
if (bandwidth_limit > std::numeric_limits<std::size_t>::max ()) if (bandwidth_limit > std::numeric_limits<std::size_t>::max ())
{ {

4
nano/node/nodeconfig.hpp
View file

@ -8,7 +8,7 @@
#include <nano/lib/numbers.hpp> #include <nano/lib/numbers.hpp>
#include <nano/lib/rocksdbconfig.hpp> #include <nano/lib/rocksdbconfig.hpp>
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/blockprocessor.hpp> #include <nano/node/blockprocessor.hpp>
#include <nano/node/bootstrap/bootstrap_config.hpp> #include <nano/node/bootstrap/bootstrap_config.hpp>
#include <nano/node/bootstrap/bootstrap_server.hpp> #include <nano/node/bootstrap/bootstrap_server.hpp>
@ -137,7 +137,7 @@ public:
nano::vote_cache_config vote_cache; nano::vote_cache_config vote_cache;
nano::rep_crawler_config rep_crawler; nano::rep_crawler_config rep_crawler;
nano::block_processor_config block_processor; nano::block_processor_config block_processor;
nano::active_transactions_config active_transactions; nano::active_elections_config active_elections;
nano::vote_processor_config vote_processor; nano::vote_processor_config vote_processor;
nano::peer_history_config peer_history; nano::peer_history_config peer_history;
nano::transport::tcp_config tcp; nano::transport::tcp_config tcp;

2
nano/node/repcrawler.cpp
View file

@ -1,4 +1,4 @@
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/repcrawler.hpp> #include <nano/node/repcrawler.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>

4
nano/node/repcrawler.hpp
View file

@ -23,7 +23,7 @@ namespace mi = boost::multi_index;
namespace nano namespace nano
{ {
class node; class node;
class active_transactions; class active_elections;
struct representative struct representative
{ {
@ -93,7 +93,7 @@ private: // Dependencies
nano::stats & stats; nano::stats & stats;
nano::logger & logger; nano::logger & logger;
nano::network_constants & network_constants; nano::network_constants & network_constants;
nano::active_transactions & active; nano::active_elections & active;
private: private:
void run (); void run ();

4
nano/node/request_aggregator.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/local_vote_history.hpp> #include <nano/node/local_vote_history.hpp>
#include <nano/node/network.hpp> #include <nano/node/network.hpp>
@ -12,7 +12,7 @@
#include <nano/secure/ledger_set_any.hpp> #include <nano/secure/ledger_set_any.hpp>
#include <nano/store/component.hpp> #include <nano/store/component.hpp>
nano::request_aggregator::request_aggregator (nano::node_config const & config_a, nano::stats & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) : nano::request_aggregator::request_aggregator (nano::node_config const & config_a, nano::stats & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_elections & active_a) :
config{ config_a }, config{ config_a },
max_delay (config_a.network_params.network.is_dev_network () ? 50 : 300), max_delay (config_a.network_params.network.is_dev_network () ? 50 : 300),
small_delay (config_a.network_params.network.is_dev_network () ? 10 : 50), small_delay (config_a.network_params.network.is_dev_network () ? 10 : 50),

6
nano/node/request_aggregator.hpp
View file

@ -19,7 +19,7 @@ namespace mi = boost::multi_index;
namespace nano namespace nano
{ {
class active_transactions; class active_elections;
class ledger; class ledger;
class local_vote_history; class local_vote_history;
class node_config; class node_config;
@ -62,7 +62,7 @@ class request_aggregator final
// clang-format on // clang-format on
public: public:
request_aggregator (nano::node_config const & config, nano::stats & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_transactions &); request_aggregator (nano::node_config const & config, nano::stats & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_elections &);
/** Add a new request by \p channel_a for hashes \p hashes_roots_a */ /** Add a new request by \p channel_a for hashes \p hashes_roots_a */
void add (std::shared_ptr<nano::transport::channel> const & channel_a, std::vector<std::pair<nano::block_hash, nano::root>> const & hashes_roots_a); void add (std::shared_ptr<nano::transport::channel> const & channel_a, std::vector<std::pair<nano::block_hash, nano::root>> const & hashes_roots_a);
@ -89,7 +89,7 @@ private:
nano::local_vote_history & local_votes; nano::local_vote_history & local_votes;
nano::ledger & ledger; nano::ledger & ledger;
nano::wallets & wallets; nano::wallets & wallets;
nano::active_transactions & active; nano::active_elections & active;
nano::vote_generator & generator; nano::vote_generator & generator;
nano::vote_generator & final_generator; nano::vote_generator & final_generator;

4
nano/node/scheduler/hinted.cpp
View file

@ -1,6 +1,6 @@
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/lib/tomlconfig.hpp> #include <nano/lib/tomlconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election_behavior.hpp> #include <nano/node/election_behavior.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/scheduler/hinted.hpp> #include <nano/node/scheduler/hinted.hpp>
@ -11,7 +11,7 @@
* hinted * hinted
*/ */
nano::scheduler::hinted::hinted (hinted_config const & config_a, nano::node & node_a, nano::vote_cache & vote_cache_a, nano::active_transactions & active_a, nano::online_reps & online_reps_a, nano::stats & stats_a) : nano::scheduler::hinted::hinted (hinted_config const & config_a, nano::node & node_a, nano::vote_cache & vote_cache_a, nano::active_elections & active_a, nano::online_reps & online_reps_a, nano::stats & stats_a) :
config{ config_a }, config{ config_a },
node{ node_a }, node{ node_a },
vote_cache{ vote_cache_a }, vote_cache{ vote_cache_a },

6
nano/node/scheduler/hinted.hpp
View file

@ -20,7 +20,7 @@ namespace nano
{ {
class node; class node;
class node_config; class node_config;
class active_transactions; class active_elections;
class vote_cache; class vote_cache;
class online_reps; class online_reps;
} }
@ -54,7 +54,7 @@ public:
class hinted final class hinted final
{ {
public: public:
hinted (hinted_config const &, nano::node &, nano::vote_cache &, nano::active_transactions &, nano::online_reps &, nano::stats &); hinted (hinted_config const &, nano::node &, nano::vote_cache &, nano::active_elections &, nano::online_reps &, nano::stats &);
~hinted (); ~hinted ();
void start (); void start ();
@ -79,7 +79,7 @@ private:
private: // Dependencies private: // Dependencies
nano::node & node; nano::node & node;
nano::vote_cache & vote_cache; nano::vote_cache & vote_cache;
nano::active_transactions & active; nano::active_elections & active;
nano::online_reps & online_reps; nano::online_reps & online_reps;
nano::stats & stats; nano::stats & stats;

2
nano/node/scheduler/manual.cpp
View file

@ -1,4 +1,4 @@
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/scheduler/manual.hpp> #include <nano/node/scheduler/manual.hpp>

4
nano/node/scheduler/optimistic.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/lib/tomlconfig.hpp> #include <nano/lib/tomlconfig.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election_behavior.hpp> #include <nano/node/election_behavior.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/scheduler/optimistic.hpp> #include <nano/node/scheduler/optimistic.hpp>
@ -9,7 +9,7 @@
#include <nano/secure/ledger_set_any.hpp> #include <nano/secure/ledger_set_any.hpp>
#include <nano/secure/ledger_set_confirmed.hpp> #include <nano/secure/ledger_set_confirmed.hpp>
nano::scheduler::optimistic::optimistic (optimistic_config const & config_a, nano::node & node_a, nano::ledger & ledger_a, nano::active_transactions & active_a, nano::network_constants const & network_constants_a, nano::stats & stats_a) : nano::scheduler::optimistic::optimistic (optimistic_config const & config_a, nano::node & node_a, nano::ledger & ledger_a, nano::active_elections & active_a, nano::network_constants const & network_constants_a, nano::stats & stats_a) :
config{ config_a }, config{ config_a },
node{ node_a }, node{ node_a },
ledger{ ledger_a }, ledger{ ledger_a },

6
nano/node/scheduler/optimistic.hpp
View file

@ -23,7 +23,7 @@ namespace mi = boost::multi_index;
namespace nano namespace nano
{ {
class account_info; class account_info;
class active_transactions; class active_elections;
class ledger; class ledger;
class node; class node;
} }
@ -51,7 +51,7 @@ class optimistic final
struct entry; struct entry;
public: public:
optimistic (optimistic_config const &, nano::node &, nano::ledger &, nano::active_transactions &, nano::network_constants const & network_constants, nano::stats &); optimistic (optimistic_config const &, nano::node &, nano::ledger &, nano::active_elections &, nano::network_constants const & network_constants, nano::stats &);
~optimistic (); ~optimistic ();
void start (); void start ();
@ -80,7 +80,7 @@ private: // Dependencies
optimistic_config const & config; optimistic_config const & config;
nano::node & node; nano::node & node;
nano::ledger & ledger; nano::ledger & ledger;
nano::active_transactions & active; nano::active_elections & active;
nano::network_constants const & network_constants; nano::network_constants const & network_constants;
nano::stats & stats; nano::stats & stats;

2
nano/node/scheduler/priority.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/scheduler/buckets.hpp> #include <nano/node/scheduler/buckets.hpp>

2
nano/node/vote_cache.hpp
View file

@ -24,7 +24,7 @@ namespace mi = boost::multi_index;
namespace nano namespace nano
{ {
class node; class node;
class active_transactions; class active_elections;
class election; class election;
class vote; class vote;
} }

4
nano/node/vote_processor.cpp
View file

@ -1,7 +1,7 @@
#include <nano/lib/stats.hpp> #include <nano/lib/stats.hpp>
#include <nano/lib/thread_roles.hpp> #include <nano/lib/thread_roles.hpp>
#include <nano/lib/timer.hpp> #include <nano/lib/timer.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/node_observers.hpp> #include <nano/node/node_observers.hpp>
#include <nano/node/nodeconfig.hpp> #include <nano/node/nodeconfig.hpp>
#include <nano/node/online_reps.hpp> #include <nano/node/online_reps.hpp>
@ -15,7 +15,7 @@
using namespace std::chrono_literals; using namespace std::chrono_literals;
nano::vote_processor::vote_processor (vote_processor_config const & config_a, nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a, nano::rep_tiers & rep_tiers_a) : nano::vote_processor::vote_processor (vote_processor_config const & config_a, nano::active_elections & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a, nano::rep_tiers & rep_tiers_a) :
config{ config_a }, config{ config_a },
active{ active_a }, active{ active_a },
observers{ observers_a }, observers{ observers_a },

6
nano/node/vote_processor.hpp
View file

@ -14,7 +14,7 @@
namespace nano namespace nano
{ {
class active_transactions; class active_elections;
namespace store namespace store
{ {
class component; class component;
@ -56,7 +56,7 @@ public:
class vote_processor final class vote_processor final
{ {
public: public:
vote_processor (vote_processor_config const &, nano::active_transactions &, nano::node_observers &, nano::stats &, nano::node_flags &, nano::logger &, nano::online_reps &, nano::rep_crawler &, nano::ledger &, nano::network_params &, nano::rep_tiers &); vote_processor (vote_processor_config const &, nano::active_elections &, nano::node_observers &, nano::stats &, nano::node_flags &, nano::logger &, nano::online_reps &, nano::rep_crawler &, nano::ledger &, nano::network_params &, nano::rep_tiers &);
~vote_processor (); ~vote_processor ();
void start (); void start ();
@ -75,7 +75,7 @@ public:
private: // Dependencies private: // Dependencies
vote_processor_config const & config; vote_processor_config const & config;
nano::active_transactions & active; nano::active_elections & active;
nano::node_observers & observers; nano::node_observers & observers;
nano::stats & stats; nano::stats & stats;
nano::logger & logger; nano::logger & logger;

2
nano/rpc_test/rpc.cpp
View file

@ -4,7 +4,7 @@
#include <nano/lib/rpcconfig.hpp> #include <nano/lib/rpcconfig.hpp>
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/lib/threading.hpp> #include <nano/lib/threading.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/ipc/ipc_server.hpp> #include <nano/node/ipc/ipc_server.hpp>

4
nano/slow_test/node.cpp
View file

@ -2,7 +2,7 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/logging.hpp> #include <nano/lib/logging.hpp>
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/confirming_set.hpp> #include <nano/node/confirming_set.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/make_store.hpp> #include <nano/node/make_store.hpp>
@ -995,7 +995,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();
node_config.online_weight_minimum = 100; node_config.online_weight_minimum = 100;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
node_config.active_transactions.size = 400000; node_config.active_elections.size = 400000;
nano::node_flags node_flags; nano::node_flags node_flags;
auto node = system.add_node (node_config); auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);

2
nano/slow_test/vote_cache.cpp
View file

@ -1,5 +1,5 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/test_common/rate_observer.hpp> #include <nano/test_common/rate_observer.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp> #include <nano/test_common/testutil.hpp>

2
nano/test_common/system.cpp
View file

@ -1,7 +1,7 @@
#include <nano/crypto_lib/random_pool.hpp> #include <nano/crypto_lib/random_pool.hpp>
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/transport/tcp_listener.hpp> #include <nano/node/transport/tcp_listener.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>

2
nano/test_common/testutil.cpp
View file

@ -1,6 +1,6 @@
#include <nano/crypto_lib/random_pool.hpp> #include <nano/crypto_lib/random_pool.hpp>
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/active_transactions.hpp> #include <nano/node/active_elections.hpp>
#include <nano/node/election.hpp> #include <nano/node/election.hpp>
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
#include <nano/node/scheduler/manual.hpp> #include <nano/node/scheduler/manual.hpp>