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

Updating and applying formatting changes. (#3209)

Browse source
This commit is contained in:
clemahieu 2021-04-19 21:37:01 +02:00 • committed by GitHub
commit 8d0a03e23d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
188 changed files with 4409 additions and 4406 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.clang-format.base
View file

@ -7,22 +7,23 @@ Standard: Cpp11
TabWidth: 4 TabWidth: 4
IndentWidth: 4 IndentWidth: 4
PointerAlignment: Middle PointerAlignment: Middle
UseTab: ForIndentation UseTab: ForContinuationAndIndentation
BreakBeforeBraces: Custom BreakBeforeBraces: Custom
AlignEscapedNewlines: Left AlignEscapedNewlines: Left
AllowShortBlocksOnASingleLine: false AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: false AllowShortFunctionsOnASingleLine: false
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false AllowShortLoopsOnASingleLine: false
BreakConstructorInitializersBeforeComma: true BreakConstructorInitializersBeforeComma: true
BreakConstructorInitializers: AfterColon BreakConstructorInitializers: AfterColon
ConstructorInitializerAllOnOneLineOrOnePerLine: false ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 0
ContinuationIndentWidth: 0 ContinuationIndentWidth: 0
KeepEmptyLinesAtTheStartOfBlocks: false KeepEmptyLinesAtTheStartOfBlocks: false
IndentCaseLabels: true IndentCaseLabels: true
SpaceBeforeCpp11BracedList: false SpaceBeforeCpp11BracedList: false
BraceWrapping: BraceWrapping:
AfterCaseLabel: true
AfterEnum: true AfterEnum: true
AfterStruct: true AfterStruct: true
SplitEmptyFunction: true SplitEmptyFunction: true
@ -33,6 +34,7 @@ BraceWrapping:
AfterClass: true AfterClass: true
BeforeCatch: true BeforeCatch: true
BeforeElse: true BeforeElse: true
BeforeLambdaBody: true
SplitEmptyRecord: true SplitEmptyRecord: true
SplitEmptyNamespace: true SplitEmptyNamespace: true
SortIncludes: true SortIncludes: true

1108
nano/core_test/active_transactions.cpp
View file

File diff suppressed because it is too large Load diff

150
nano/core_test/block.cpp
View file

@ -462,13 +462,13 @@ TEST (block_builder, from)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.state () .state ()
.account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to") .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
.previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5") .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
.balance_dec ("2251569974100400000000000000000000") .balance_dec ("2251569974100400000000000000000000")
.representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou") .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
.link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86") .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F");
auto block2 = builder.state ().from (*block).build (ec); auto block2 = builder.state ().from (*block).build (ec);
@ -495,13 +495,13 @@ TEST (block_builder, state)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.state () .state ()
.account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to") .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
.previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5") .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
.balance_dec ("2251569974100400000000000000000000") .balance_dec ("2251569974100400000000000000000000")
.representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou") .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
.link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86") .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F");
ASSERT_TRUE (block->source ().is_zero ()); ASSERT_TRUE (block->source ().is_zero ());
ASSERT_TRUE (block->destination ().is_zero ()); ASSERT_TRUE (block->destination ().is_zero ());
@ -514,14 +514,14 @@ TEST (block_builder, state_missing_rep)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.state () .state ()
.account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to") .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
.previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5") .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
.balance_dec ("2251569974100400000000000000000000") .balance_dec ("2251569974100400000000000000000000")
.link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86") .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
.sign_zero () .sign_zero ()
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_EQ (ec, nano::error_common::missing_representative); ASSERT_EQ (ec, nano::error_common::missing_representative);
} }
@ -536,15 +536,15 @@ TEST (block_builder, state_equality)
// With builder // With builder
auto block2 = builder auto block2 = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
.previous (1) .previous (1)
.representative (key2.pub) .representative (key2.pub)
.balance (2) .balance (2)
.link (4) .link (4)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (5) .work (5)
.build (ec); .build (ec);
ASSERT_NO_ERROR (ec); ASSERT_NO_ERROR (ec);
ASSERT_EQ (block1.hash (), block2->hash ()); ASSERT_EQ (block1.hash (), block2->hash ());
@ -570,11 +570,11 @@ TEST (block_builder, open)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.open () .open ()
.account_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3") .account_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
.representative_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3") .representative_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
.source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA") .source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948");
ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA");
ASSERT_TRUE (block->destination ().is_zero ()); ASSERT_TRUE (block->destination ().is_zero ());
@ -592,13 +592,13 @@ TEST (block_builder, open_equality)
// With builder // With builder
auto block2 = builder auto block2 = builder
.open () .open ()
.source (1) .source (1)
.account (key2.pub) .account (key2.pub)
.representative (key1.pub) .representative (key1.pub)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (5) .work (5)
.build (ec); .build (ec);
ASSERT_NO_ERROR (ec); ASSERT_NO_ERROR (ec);
ASSERT_EQ (block1.hash (), block2->hash ()); ASSERT_EQ (block1.hash (), block2->hash ());
@ -610,10 +610,10 @@ TEST (block_builder, change)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.change () .change ()
.representative_address ("xrb_3rropjiqfxpmrrkooej4qtmm1pueu36f9ghinpho4esfdor8785a455d16nf") .representative_address ("xrb_3rropjiqfxpmrrkooej4qtmm1pueu36f9ghinpho4esfdor8785a455d16nf")
.previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456") .previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077");
ASSERT_TRUE (block->source ().is_zero ()); ASSERT_TRUE (block->source ().is_zero ());
ASSERT_TRUE (block->destination ().is_zero ()); ASSERT_TRUE (block->destination ().is_zero ());
@ -631,12 +631,12 @@ TEST (block_builder, change_equality)
// With builder // With builder
auto block2 = builder auto block2 = builder
.change () .change ()
.previous (1) .previous (1)
.representative (key1.pub) .representative (key1.pub)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (5) .work (5)
.build (ec); .build (ec);
ASSERT_NO_ERROR (ec); ASSERT_NO_ERROR (ec);
ASSERT_EQ (block1.hash (), block2->hash ()); ASSERT_EQ (block1.hash (), block2->hash ());
@ -648,11 +648,11 @@ TEST (block_builder, send)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.send () .send ()
.destination_address ("xrb_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb") .destination_address ("xrb_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb")
.previous_hex ("F685856D73A488894F7F3A62BC3A88E17E985F9969629FF3FDD4A0D4FD823F24") .previous_hex ("F685856D73A488894F7F3A62BC3A88E17E985F9969629FF3FDD4A0D4FD823F24")
.balance_hex ("00F035A9C7D818E7C34148C524FFFFEE") .balance_hex ("00F035A9C7D818E7C34148C524FFFFEE")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD");
ASSERT_TRUE (block->source ().is_zero ()); ASSERT_TRUE (block->source ().is_zero ());
ASSERT_EQ (block->destination ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_EQ (block->destination ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb");
@ -670,13 +670,13 @@ TEST (block_builder, send_equality)
// With builder // With builder
auto block2 = builder auto block2 = builder
.send () .send ()
.previous (1) .previous (1)
.destination (key1.pub) .destination (key1.pub)
.balance (2) .balance (2)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (5) .work (5)
.build (ec); .build (ec);
ASSERT_NO_ERROR (ec); ASSERT_NO_ERROR (ec);
ASSERT_EQ (block1.hash (), block2->hash ()); ASSERT_EQ (block1.hash (), block2->hash ());
@ -694,12 +694,12 @@ TEST (block_builder, receive_equality)
// With builder // With builder
auto block2 = builder auto block2 = builder
.receive () .receive ()
.previous (1) .previous (1)
.source (2) .source (2)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (5) .work (5)
.build (ec); .build (ec);
ASSERT_NO_ERROR (ec); ASSERT_NO_ERROR (ec);
ASSERT_EQ (block1.hash (), block2->hash ()); ASSERT_EQ (block1.hash (), block2->hash ());
@ -711,10 +711,10 @@ TEST (block_builder, receive)
std::error_code ec; std::error_code ec;
nano::block_builder builder; nano::block_builder builder;
auto block = builder auto block = builder
.receive () .receive ()
.previous_hex ("59660153194CAC5DAC08509D87970BF86F6AEA943025E2A7ED7460930594950E") .previous_hex ("59660153194CAC5DAC08509D87970BF86F6AEA943025E2A7ED7460930594950E")
.source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135") .source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135")
.build (ec); .build (ec);
ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722");
ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135");
ASSERT_TRUE (block->destination ().is_zero ()); ASSERT_TRUE (block->destination ().is_zero ());

4
nano/core_test/block_store.cpp
View file

@ -1434,7 +1434,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
nano::state_block block2 (nano::dev_genesis_key.pub, block1.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); nano::state_block block2 (nano::dev_genesis_key.pub, block1.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ()));
nano::state_block block3 (nano::dev_genesis_key.pub, block2.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 2, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ())); nano::state_block block3 (nano::dev_genesis_key.pub, block2.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 2, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ()));
auto code = [&block1, &block2, &block3](auto confirmation_height, nano::block_hash const & expected_cemented_frontier) { auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
auto path (nano::unique_path ()); auto path (nano::unique_path ());
nano::mdb_val value; nano::mdb_val value;
{ {
@ -1854,7 +1854,7 @@ TEST (mdb_block_store, upgrade_backup)
fs::create_directory (dir); fs::create_directory (dir);
auto path = dir / "data.ldb"; auto path = dir / "data.ldb";
/** Returns 'dir' if backup file cannot be found */ /** Returns 'dir' if backup file cannot be found */
auto get_backup_path = [&dir]() { auto get_backup_path = [&dir] () {
for (fs::directory_iterator itr (dir); itr != fs::directory_iterator (); ++itr) for (fs::directory_iterator itr (dir); itr != fs::directory_iterator (); ++itr)
{ {
if (itr->path ().filename ().string ().find ("data_backup_") != std::string::npos) if (itr->path ().filename ().string ().find ("data_backup_") != std::string::npos)

14
nano/core_test/distributed_work.cpp
View file

@ -20,7 +20,7 @@ TEST (distributed_work, no_peers)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; boost::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done](boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
work = work_a; work = work_a;
done = true; done = true;
@ -54,7 +54,7 @@ TEST (distributed_work, no_peers_cancel)
auto & node = *system.add_node (node_config); auto & node = *system.add_node (node_config);
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
bool done{ false }; bool done{ false };
auto callback_to_cancel = [&done](boost::optional<uint64_t> work_a) { auto callback_to_cancel = [&done] (boost::optional<uint64_t> work_a) {
ASSERT_FALSE (work_a.is_initialized ()); ASSERT_FALSE (work_a.is_initialized ());
done = true; done = true;
}; };
@ -83,7 +83,7 @@ TEST (distributed_work, no_peers_multi)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
unsigned total{ 10 }; unsigned total{ 10 };
std::atomic<unsigned> count{ 0 }; std::atomic<unsigned> count{ 0 };
auto callback = [&count](boost::optional<uint64_t> work_a) { auto callback = [&count] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
++count; ++count;
}; };
@ -127,7 +127,7 @@ TEST (distributed_work, peer)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; boost::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done](boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
work = work_a; work = work_a;
done = true; done = true;
@ -153,7 +153,7 @@ TEST (distributed_work, peer_malicious)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; boost::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done](boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
work = work_a; work = work_a;
done = true; done = true;
@ -193,7 +193,7 @@ TEST (distributed_work, peer_multi)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; boost::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done](boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
work = work_a; work = work_a;
done = true; done = true;
@ -232,7 +232,7 @@ TEST (distributed_work, fail_resolve)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; boost::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done](boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.is_initialized ());
work = work_a; work = work_a;
done = true; done = true;

144
nano/core_test/election.cpp
View file

@ -26,25 +26,25 @@ TEST (election, quorum_minimum_flip_success)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ()) .balance (node1.online_reps.delta ())
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
nano::keypair key2; nano::keypair key2;
auto send2 = builder.state () auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ()) .balance (node1.online_reps.delta ())
.link (key2.pub) .link (key2.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send2); node1.work_generate_blocking (*send2);
node1.process_active (send1); node1.process_active (send1);
node1.process_active (send2); node1.process_active (send2);
@ -70,25 +70,25 @@ TEST (election, quorum_minimum_flip_fail)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1) .balance (node1.online_reps.delta () - 1)
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
nano::keypair key2; nano::keypair key2;
auto send2 = builder.state () auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1) .balance (node1.online_reps.delta () - 1)
.link (key2.pub) .link (key2.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send2); node1.work_generate_blocking (*send2);
node1.process_active (send1); node1.process_active (send1);
node1.process_active (send2); node1.process_active (send2);
@ -114,14 +114,14 @@ TEST (election, quorum_minimum_confirm_success)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ()) .balance (node1.online_reps.delta ())
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
node1.process_active (send1); node1.process_active (send1);
node1.block_processor.flush (); node1.block_processor.flush ();
@ -146,14 +146,14 @@ TEST (election, quorum_minimum_confirm_fail)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1) .balance (node1.online_reps.delta () - 1)
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
node1.process_active (send1); node1.process_active (send1);
node1.block_processor.flush (); node1.block_processor.flush ();
@ -181,34 +181,34 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (amount) .balance (amount)
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
auto open1 = builder.state () auto open1 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (key1.pub) .representative (key1.pub)
.balance (nano::genesis_amount - amount) .balance (nano::genesis_amount - amount)
.link (send1->hash ()) .link (send1->hash ())
.work (0) .work (0)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.build_shared (); .build_shared ();
nano::keypair key2; nano::keypair key2;
auto send2 = builder.state () auto send2 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (open1->hash ()) .previous (open1->hash ())
.representative (key1.pub) .representative (key1.pub)
.balance (3) .balance (3)
.link (key2.pub) .link (key2.pub)
.work (0) .work (0)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*open1); node1.work_generate_blocking (*open1);
node1.work_generate_blocking (*send2); node1.work_generate_blocking (*send2);
node1.process_active (send1); node1.process_active (send1);

6
nano/core_test/fakes/websocket_client.hpp
View file

@ -17,7 +17,7 @@ class fake_websocket_client
{ {
public: public:
fake_websocket_client (unsigned port) : fake_websocket_client (unsigned port) :
socket (std::make_shared<boost::beast::websocket::stream<boost::asio::ip::tcp::socket>> (ioc)) socket (std::make_shared<boost::beast::websocket::stream<boost::asio::ip::tcp::socket>> (ioc))
{ {
std::string const host = "::1"; std::string const host = "::1";
boost::asio::ip::tcp::resolver resolver{ ioc }; boost::asio::ip::tcp::resolver resolver{ ioc };
@ -31,7 +31,7 @@ public:
{ {
if (socket->is_open ()) if (socket->is_open ())
{ {
socket->async_close (boost::beast::websocket::close_code::normal, [socket = this->socket](boost::beast::error_code const & ec) { socket->async_close (boost::beast::websocket::close_code::normal, [socket = this->socket] (boost::beast::error_code const & ec) {
// A synchronous close usually hangs in tests when the server's io_context stops looping // A synchronous close usually hangs in tests when the server's io_context stops looping
// An async_close solves this problem // An async_close solves this problem
}); });
@ -55,7 +55,7 @@ public:
debug_assert (deadline > 0s); debug_assert (deadline > 0s);
boost::optional<std::string> result; boost::optional<std::string> result;
auto buffer (std::make_shared<boost::beast::flat_buffer> ()); auto buffer (std::make_shared<boost::beast::flat_buffer> ());
socket->async_read (*buffer, [&result, &buffer, socket = this->socket](boost::beast::error_code const & ec, std::size_t const /*n*/) { socket->async_read (*buffer, [&result, &buffer, socket = this->socket] (boost::beast::error_code const & ec, std::size_t const /*n*/) {
if (!ec) if (!ec)
{ {
std::ostringstream res; std::ostringstream res;

46
nano/core_test/fakes/work_peer.hpp
View file

@ -35,14 +35,14 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
const std::string generic_error = "Unable to parse JSON"; const std::string generic_error = "Unable to parse JSON";
public: public:
work_peer_connection (asio::io_context & ioc_a, work_peer_type const type_a, nano::work_version const version_a, nano::work_pool & pool_a, std::function<void(bool const)> on_generation_a, std::function<void()> on_cancel_a) : work_peer_connection (asio::io_context & ioc_a, work_peer_type const type_a, nano::work_version const version_a, nano::work_pool & pool_a, std::function<void (bool const)> on_generation_a, std::function<void ()> on_cancel_a) :
socket (ioc_a), socket (ioc_a),
type (type_a), type (type_a),
version (version_a), version (version_a),
work_pool (pool_a), work_pool (pool_a),
on_generation (on_generation_a), on_generation (on_generation_a),
on_cancel (on_cancel_a), on_cancel (on_cancel_a),
timer (ioc_a) timer (ioc_a)
{ {
} }
void start () void start ()
@ -58,14 +58,14 @@ private:
beast::flat_buffer buffer{ 8192 }; beast::flat_buffer buffer{ 8192 };
http::request<http::string_body> request; http::request<http::string_body> request;
http::response<http::dynamic_body> response; http::response<http::dynamic_body> response;
std::function<void(bool const)> on_generation; std::function<void (bool const)> on_generation;
std::function<void()> on_cancel; std::function<void ()> on_cancel;
asio::deadline_timer timer; asio::deadline_timer timer;
void read_request () void read_request ()
{ {
auto this_l = shared_from_this (); auto this_l = shared_from_this ();
http::async_read (socket, buffer, request, [this_l](beast::error_code ec, std::size_t const /*size_a*/) { http::async_read (socket, buffer, request, [this_l] (beast::error_code ec, std::size_t const /*size_a*/) {
if (!ec) if (!ec)
{ {
this_l->process_request (); this_l->process_request ();
@ -110,7 +110,7 @@ private:
{ {
auto this_l = shared_from_this (); auto this_l = shared_from_this ();
response.content_length (response.body ().size ()); response.content_length (response.body ().size ());
http::async_write (socket, response, [this_l](beast::error_code ec, std::size_t /*size_a*/) { http::async_write (socket, response, [this_l] (beast::error_code ec, std::size_t /*size_a*/) {
this_l->socket.shutdown (tcp::socket::shutdown_send, ec); this_l->socket.shutdown (tcp::socket::shutdown_send, ec);
this_l->socket.close (); this_l->socket.close ();
}); });
@ -143,7 +143,7 @@ private:
auto hash = hash_a; auto hash = hash_a;
auto request_difficulty = nano::work_threshold_base (version); auto request_difficulty = nano::work_threshold_base (version);
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
work_pool.generate (version, hash, request_difficulty, [this_l, hash](boost::optional<uint64_t> work_a) { work_pool.generate (version, hash, request_difficulty, [this_l, hash] (boost::optional<uint64_t> work_a) {
auto result = work_a.value_or (0); auto result = work_a.value_or (0);
auto result_difficulty (nano::work_difficulty (this_l->version, hash, result)); auto result_difficulty (nano::work_difficulty (this_l->version, hash, result));
static nano::network_params params; static nano::network_params params;
@ -157,7 +157,7 @@ private:
beast::ostream (this_l->response.body ()) << ostream.str (); beast::ostream (this_l->response.body ()) << ostream.str ();
// Delay response by 500ms as a slow peer, immediate async call for a good peer // Delay response by 500ms as a slow peer, immediate async call for a good peer
this_l->timer.expires_from_now (boost::posix_time::milliseconds (this_l->type == work_peer_type::slow ? 500 : 0)); this_l->timer.expires_from_now (boost::posix_time::milliseconds (this_l->type == work_peer_type::slow ? 500 : 0));
this_l->timer.async_wait ([this_l, result](const boost::system::error_code & ec) { this_l->timer.async_wait ([this_l, result] (const boost::system::error_code & ec) {
if (this_l->on_generation) if (this_l->on_generation)
{ {
this_l->on_generation (result != 0); this_l->on_generation (result != 0);
@ -200,12 +200,12 @@ class fake_work_peer : public std::enable_shared_from_this<fake_work_peer>
public: public:
fake_work_peer () = delete; fake_work_peer () = delete;
fake_work_peer (nano::work_pool & pool_a, asio::io_context & ioc_a, unsigned short port_a, work_peer_type const type_a, nano::work_version const version_a = nano::work_version::work_1) : fake_work_peer (nano::work_pool & pool_a, asio::io_context & ioc_a, unsigned short port_a, work_peer_type const type_a, nano::work_version const version_a = nano::work_version::work_1) :
pool (pool_a), pool (pool_a),
endpoint (tcp::v4 (), port_a), endpoint (tcp::v4 (), port_a),
ioc (ioc_a), ioc (ioc_a),
acceptor (ioc_a, endpoint), acceptor (ioc_a, endpoint),
type (type_a), type (type_a),
version (version_a) version (version_a)
{ {
} }
void start () void start ()
@ -226,7 +226,7 @@ private:
std::weak_ptr<fake_work_peer> this_w (shared_from_this ()); std::weak_ptr<fake_work_peer> this_w (shared_from_this ());
auto connection (std::make_shared<work_peer_connection> ( auto connection (std::make_shared<work_peer_connection> (
ioc, type, version, pool, ioc, type, version, pool,
[this_w](bool const good_generation) { [this_w] (bool const good_generation) {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
if (good_generation) if (good_generation)
@ -239,13 +239,13 @@ private:
} }
}; };
}, },
[this_w]() { [this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
++this_l->cancels; ++this_l->cancels;
} }
})); }));
acceptor.async_accept (connection->socket, [connection, this_w](beast::error_code ec) { acceptor.async_accept (connection->socket, [connection, this_w] (beast::error_code ec) {
if (!ec) if (!ec)
{ {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())

4
nano/core_test/frontiers_confirmation.cpp
View file

@ -69,8 +69,8 @@ TEST (frontiers_confirmation, prioritize_frontiers)
auto transaction = node->store.tx_begin_read (); auto transaction = node->store.tx_begin_read ();
constexpr auto num_accounts = 5; constexpr auto num_accounts = 5;
auto priority_orders_match = [](auto const & cementable_frontiers, auto const & desired_order) { auto priority_orders_match = [] (auto const & cementable_frontiers, auto const & desired_order) {
return std::equal (desired_order.begin (), desired_order.end (), cementable_frontiers.template get<1> ().begin (), cementable_frontiers.template get<1> ().end (), [](nano::account const & account, nano::cementable_account const & cementable_account) { return std::equal (desired_order.begin (), desired_order.end (), cementable_frontiers.template get<1> ().begin (), cementable_frontiers.template get<1> ().end (), [] (nano::account const & account, nano::cementable_account const & cementable_account) {
return (account == cementable_account.account); return (account == cementable_account.account);
}); });
}; };

10
nano/core_test/ipc.cpp
View file

@ -29,17 +29,17 @@ TEST (ipc, asynchronous)
auto req (nano::ipc::prepare_request (nano::ipc::payload_encoding::json_v1, std::string (R"({"action": "block_count"})"))); auto req (nano::ipc::prepare_request (nano::ipc::payload_encoding::json_v1, std::string (R"({"action": "block_count"})")));
auto res (std::make_shared<std::vector<uint8_t>> ()); auto res (std::make_shared<std::vector<uint8_t>> ());
std::atomic<bool> call_completed{ false }; std::atomic<bool> call_completed{ false };
client.async_connect ("::1", 24077, [&client, &req, &res, &call_completed](nano::error err) { client.async_connect ("::1", 24077, [&client, &req, &res, &call_completed] (nano::error err) {
client.async_write (req, [&client, &req, &res, &call_completed](nano::error err_a, size_t size_a) { client.async_write (req, [&client, &req, &res, &call_completed] (nano::error err_a, size_t size_a) {
ASSERT_NO_ERROR (static_cast<std::error_code> (err_a)); ASSERT_NO_ERROR (static_cast<std::error_code> (err_a));
ASSERT_EQ (size_a, req.size ()); ASSERT_EQ (size_a, req.size ());
// Read length // Read length
client.async_read (res, sizeof (uint32_t), [&client, &res, &call_completed](nano::error err_read_a, size_t size_read_a) { client.async_read (res, sizeof (uint32_t), [&client, &res, &call_completed] (nano::error err_read_a, size_t size_read_a) {
ASSERT_NO_ERROR (static_cast<std::error_code> (err_read_a)); ASSERT_NO_ERROR (static_cast<std::error_code> (err_read_a));
ASSERT_EQ (size_read_a, sizeof (uint32_t)); ASSERT_EQ (size_read_a, sizeof (uint32_t));
uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ())); uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ()));
// Read json payload // Read json payload
client.async_read (res, payload_size_l, [&res, &call_completed](nano::error err_read_a, size_t size_read_a) { client.async_read (res, payload_size_l, [&res, &call_completed] (nano::error err_read_a, size_t size_read_a) {
std::string payload (res->begin (), res->end ()); std::string payload (res->begin (), res->end ());
std::stringstream ss; std::stringstream ss;
ss << payload; ss << payload;
@ -68,7 +68,7 @@ TEST (ipc, synchronous)
// Start blocking IPC client in a separate thread // Start blocking IPC client in a separate thread
std::atomic<bool> call_completed{ false }; std::atomic<bool> call_completed{ false };
std::thread client_thread ([&client, &call_completed]() { std::thread client_thread ([&client, &call_completed] () {
client.connect ("::1", 24077); client.connect ("::1", 24077);
std::string response (nano::ipc::request (nano::ipc::payload_encoding::json_v1, client, std::string (R"({"action": "block_count"})"))); std::string response (nano::ipc::request (nano::ipc::payload_encoding::json_v1, client, std::string (R"({"action": "block_count"})")));
std::stringstream ss; std::stringstream ss;

384
nano/core_test/ledger.cpp
View file

@ -843,14 +843,14 @@ TEST (votes, add_existing)
nano::keypair key1; nano::keypair key1;
nano::block_builder builder; nano::block_builder builder;
std::shared_ptr<nano::block> send1 = builder.state () std::shared_ptr<nano::block> send1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
.balance (nano::genesis_amount / 2 - nano::Gxrb_ratio) .balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
.link (key1.pub) .link (key1.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build (); .build ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
auto election1 = node1.active.insert (send1); auto election1 = node1.active.insert (send1);
@ -861,14 +861,14 @@ TEST (votes, add_existing)
ASSERT_EQ (1, election1.election->last_votes[nano::dev_genesis_key.pub].timestamp); ASSERT_EQ (1, election1.election->last_votes[nano::dev_genesis_key.pub].timestamp);
nano::keypair key2; nano::keypair key2;
std::shared_ptr<nano::block> send2 = builder.state () std::shared_ptr<nano::block> send2 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
.balance (nano::genesis_amount / 2 - nano::Gxrb_ratio) .balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
.link (key2.pub) .link (key2.pub)
.work (0) .work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.build (); .build ();
node1.work_generate_blocking (*send2); node1.work_generate_blocking (*send2);
auto vote2 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send2)); auto vote2 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send2));
// Pretend we've waited the timeout // Pretend we've waited the timeout
@ -2637,14 +2637,14 @@ TEST (ledger, epoch_open_pending)
nano::work_pool pool (std::numeric_limits<unsigned>::max ()); nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1; nano::keypair key1;
auto epoch_open = builder.state () auto epoch_open = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (0) .representative (0)
.balance (0) .balance (0)
.link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (key1.pub)) .work (*pool.generate (key1.pub))
.build_shared (); .build_shared ();
auto process_result (node1.ledger.process (node1.store.tx_begin_write (), *epoch_open)); auto process_result (node1.ledger.process (node1.store.tx_begin_write (), *epoch_open));
ASSERT_EQ (nano::process_result::gap_epoch_open_pending, process_result.code); ASSERT_EQ (nano::process_result::gap_epoch_open_pending, process_result.code);
ASSERT_EQ (nano::signature_verification::valid_epoch, process_result.verified); ASSERT_EQ (nano::signature_verification::valid_epoch, process_result.verified);
@ -2658,14 +2658,14 @@ TEST (ledger, epoch_open_pending)
ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch);
// New block to process epoch open // New block to process epoch open
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (nano::genesis_hash)) .work (*pool.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
node1.block_processor.add (send1); node1.block_processor.add (send1);
node1.block_processor.flush (); node1.block_processor.flush ();
ASSERT_TRUE (node1.ledger.block_exists (epoch_open->hash ())); ASSERT_TRUE (node1.ledger.block_exists (epoch_open->hash ()));
@ -2686,24 +2686,24 @@ TEST (ledger, block_hash_account_conflict)
* in the ledger and not an account * in the ledger and not an account
*/ */
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (genesis.hash ())) .work (*pool.generate (genesis.hash ()))
.build_shared (); .build_shared ();
auto receive1 = builder.state () auto receive1 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (100) .balance (100)
.link (send1->hash ()) .link (send1->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub)) .work (*pool.generate (key1.pub))
.build_shared (); .build_shared ();
/* /*
* Note that the below link is a block hash when this is intended * Note that the below link is a block hash when this is intended
@ -2712,28 +2712,28 @@ TEST (ledger, block_hash_account_conflict)
* for arbitrary accounts. * for arbitrary accounts.
*/ */
auto send2 = builder.state () auto send2 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (receive1->hash ()) .previous (receive1->hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (90) .balance (90)
.link (receive1->hash ()) .link (receive1->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*pool.generate (receive1->hash ())) .work (*pool.generate (receive1->hash ()))
.build_shared (); .build_shared ();
/* /*
* Generate an epoch open for the account with the same value as the block hash * Generate an epoch open for the account with the same value as the block hash
*/ */
auto receive1_hash = receive1->hash (); auto receive1_hash = receive1->hash ();
auto open_epoch1 = builder.state () auto open_epoch1 = builder.state ()
.account (reinterpret_cast<nano::account const &> (receive1_hash)) .account (reinterpret_cast<nano::account const &> (receive1_hash))
.previous (0) .previous (0)
.representative (0) .representative (0)
.balance (0) .balance (0)
.link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (receive1->hash ())) .work (*pool.generate (receive1->hash ()))
.build_shared (); .build_shared ();
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
node1.work_generate_blocking (*receive1); node1.work_generate_blocking (*receive1);
@ -3040,27 +3040,27 @@ TEST (ledger, zero_rep)
nano::genesis genesis; nano::genesis genesis;
nano::block_builder builder; nano::block_builder builder;
auto block1 = builder.state () auto block1 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (0) .representative (0)
.balance (nano::genesis_amount) .balance (nano::genesis_amount)
.link (0) .link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (genesis.hash ())) .work (*system.work.generate (genesis.hash ()))
.build (); .build ();
auto transaction (node1.store.tx_begin_write ()); auto transaction (node1.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block1).code); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block1).code);
ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub));
ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (0));
auto block2 = builder.state () auto block2 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (block1->hash ()) .previous (block1->hash ())
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount) .balance (nano::genesis_amount)
.link (0) .link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (block1->hash ())) .work (*system.work.generate (block1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block2).code); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block2).code);
ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub)); ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub));
ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0));
@ -3081,7 +3081,7 @@ TEST (ledger, work_validation)
nano::keypair key; nano::keypair key;
// With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result // With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result
auto process_block = [&store, &ledger, &pool](nano::block & block_a, nano::block_details const details_a) { auto process_block = [&store, &ledger, &pool] (nano::block & block_a, nano::block_details const details_a) {
auto threshold = nano::work_threshold (block_a.work_version (), details_a); auto threshold = nano::work_threshold (block_a.work_version (), details_a);
// Rarely failed with random work, so modify until it doesn't have enough difficulty // Rarely failed with random work, so modify until it doesn't have enough difficulty
while (block_a.difficulty () >= threshold) while (block_a.difficulty () >= threshold)
@ -3096,59 +3096,59 @@ TEST (ledger, work_validation)
std::error_code ec; std::error_code ec;
auto send = *builder.send () auto send = *builder.send ()
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.destination (gen.pub) .destination (gen.pub)
.balance (nano::genesis_amount - 1) .balance (nano::genesis_amount - 1)
.sign (gen.prv, gen.pub) .sign (gen.prv, gen.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
auto receive = *builder.receive () auto receive = *builder.receive ()
.previous (send.hash ()) .previous (send.hash ())
.source (send.hash ()) .source (send.hash ())
.sign (gen.prv, gen.pub) .sign (gen.prv, gen.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
auto change = *builder.change () auto change = *builder.change ()
.previous (receive.hash ()) .previous (receive.hash ())
.representative (key.pub) .representative (key.pub)
.sign (gen.prv, gen.pub) .sign (gen.prv, gen.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
auto state = *builder.state () auto state = *builder.state ()
.account (gen.pub) .account (gen.pub)
.previous (change.hash ()) .previous (change.hash ())
.representative (gen.pub) .representative (gen.pub)
.balance (nano::genesis_amount - 1) .balance (nano::genesis_amount - 1)
.link (key.pub) .link (key.pub)
.sign (gen.prv, gen.pub) .sign (gen.prv, gen.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
auto open = *builder.open () auto open = *builder.open ()
.account (key.pub) .account (key.pub)
.source (state.hash ()) .source (state.hash ())
.representative (key.pub) .representative (key.pub)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
auto epoch = *builder.state () auto epoch = *builder.state ()
.account (key.pub) .account (key.pub)
.previous (open.hash ()) .previous (open.hash ())
.balance (1) .balance (1)
.representative (key.pub) .representative (key.pub)
.link (ledger.epoch_link (nano::epoch::epoch_1)) .link (ledger.epoch_link (nano::epoch::epoch_1))
.sign (gen.prv, gen.pub) .sign (gen.prv, gen.pub)
.work (0) .work (0)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
process_block (send, {}); process_block (send, {});
@ -3174,36 +3174,36 @@ TEST (ledger, dependents_confirmed)
nano::work_pool pool (std::numeric_limits<unsigned>::max ()); nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1; nano::keypair key1;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (genesis.hash ())) .work (*pool.generate (genesis.hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1));
auto send2 = builder.state () auto send2 = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (send1->hash ()) .previous (send1->hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 200) .balance (nano::genesis_amount - 200)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (send1->hash ())) .work (*pool.generate (send1->hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code);
ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2));
auto receive1 = builder.state () auto receive1 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (100) .balance (100)
.link (send1->hash ()) .link (send1->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub)) .work (*pool.generate (key1.pub))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code);
ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1));
nano::confirmation_height_info height; nano::confirmation_height_info height;
@ -3212,14 +3212,14 @@ TEST (ledger, dependents_confirmed)
ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); ledger.store.confirmation_height_put (transaction, nano::genesis_account, height);
ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1));
auto receive2 = builder.state () auto receive2 = builder.state ()
.account (key1.pub) .account (key1.pub)
.previous (receive1->hash ()) .previous (receive1->hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (200) .balance (200)
.link (send2->hash ()) .link (send2->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*pool.generate (receive1->hash ())) .work (*pool.generate (receive1->hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code);
ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2));
ASSERT_TRUE (ledger.store.confirmation_height_get (transaction, key1.pub, height)); ASSERT_TRUE (ledger.store.confirmation_height_get (transaction, key1.pub, height));
@ -3247,14 +3247,14 @@ TEST (ledger, block_confirmed)
nano::work_pool pool (std::numeric_limits<unsigned>::max ()); nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1; nano::keypair key1;
auto send1 = builder.state () auto send1 = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (genesis.hash ())) .work (*pool.generate (genesis.hash ()))
.build (); .build ();
// Must be safe against non-existing blocks // Must be safe against non-existing blocks
ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
@ -3289,7 +3289,7 @@ TEST (ledger, cache)
auto genesis_weight = nano::genesis_amount - i; auto genesis_weight = nano::genesis_amount - i;
auto pruned_count = i; auto pruned_count = i;
auto cache_check = [&, i](nano::ledger_cache const & cache_a) { auto cache_check = [&, i] (nano::ledger_cache const & cache_a) {
ASSERT_EQ (account_count, cache_a.account_count); ASSERT_EQ (account_count, cache_a.account_count);
ASSERT_EQ (block_count, cache_a.block_count); ASSERT_EQ (block_count, cache_a.block_count);
ASSERT_EQ (cemented_count, cache_a.cemented_count); ASSERT_EQ (cemented_count, cache_a.cemented_count);
@ -3300,23 +3300,23 @@ TEST (ledger, cache)
nano::keypair key; nano::keypair key;
auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account);
auto send = builder.state () auto send = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (latest) .previous (latest)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - (i + 1)) .balance (nano::genesis_amount - (i + 1))
.link (key.pub) .link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (latest)) .work (*pool.generate (latest))
.build (); .build ();
auto open = builder.state () auto open = builder.state ()
.account (key.pub) .account (key.pub)
.previous (0) .previous (0)
.representative (key.pub) .representative (key.pub)
.balance (1) .balance (1)
.link (send->hash ()) .link (send->hash ())
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*pool.generate (key.pub)) .work (*pool.generate (key.pub))
.build (); .build ();
{ {
auto transaction (store->tx_begin_write ()); auto transaction (store->tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
@ -3778,14 +3778,14 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
nano::work_pool pool (std::numeric_limits<unsigned>::max ()); nano::work_pool pool (std::numeric_limits<unsigned>::max ());
auto send = nano::state_block_builder () auto send = nano::state_block_builder ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (0) .representative (0)
.link (nano::account (10)) .link (nano::account (10))
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (nano::genesis_hash)) .work (*pool.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
nano::endpoint_key endpoint_key (address.to_bytes (), port); nano::endpoint_key endpoint_key (address.to_bytes (), port);
auto version = 99; auto version = 99;
@ -3865,14 +3865,14 @@ TEST (ledger, unconfirmed_frontiers)
nano::keypair key; nano::keypair key;
auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account);
auto send = builder.make_block () auto send = builder.make_block ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (latest) .previous (latest)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - 100) .balance (nano::genesis_amount - 100)
.link (key.pub) .link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (latest)) .work (*pool.generate (latest))
.build (); .build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);

2
nano/core_test/locks.cpp
View file

@ -156,7 +156,7 @@ TEST (locks, condition_variable_wait_until)
nano::condition_variable cv; nano::condition_variable cv;
nano::mutex mutex; nano::mutex mutex;
auto impl = [&](auto time_to_sleep) { auto impl = [&] (auto time_to_sleep) {
std::atomic<bool> notified{ false }; std::atomic<bool> notified{ false };
std::atomic<bool> finished{ false }; std::atomic<bool> finished{ false };
nano::unique_lock<nano::mutex> lk (mutex); nano::unique_lock<nano::mutex> lk (mutex);

2
nano/core_test/memory_pool.cpp
View file

@ -17,7 +17,7 @@ public:
using value_type = T; using value_type = T;
explicit record_allocations_new_delete_allocator (std::vector<size_t> * allocated) : explicit record_allocations_new_delete_allocator (std::vector<size_t> * allocated) :
allocated (allocated) allocated (allocated)
{ {
} }

48
nano/core_test/network.cpp
View file

@ -25,7 +25,7 @@ TEST (network, tcp_connection)
std::atomic<bool> done1 (false); std::atomic<bool> done1 (false);
std::string message1; std::string message1;
acceptor.async_accept (incoming, acceptor.async_accept (incoming,
[&done1, &message1](boost::system::error_code const & ec_a) { [&done1, &message1] (boost::system::error_code const & ec_a) {
if (ec_a) if (ec_a)
{ {
message1 = ec_a.message (); message1 = ec_a.message ();
@ -36,7 +36,7 @@ TEST (network, tcp_connection)
std::atomic<bool> done2 (false); std::atomic<bool> done2 (false);
std::string message2; std::string message2;
connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), port), connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), port),
[&done2, &message2](boost::system::error_code const & ec_a) { [&done2, &message2] (boost::system::error_code const & ec_a) {
if (ec_a) if (ec_a)
{ {
message2 = ec_a.message (); message2 = ec_a.message ();
@ -283,7 +283,7 @@ TEST (network, send_insufficient_work_udp)
auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
nano::publish publish (block); nano::publish publish (block);
nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.protocol.protocol_version); nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.protocol.protocol_version);
channel.send (publish, [](boost::system::error_code const & ec, size_t size) {}); channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
@ -298,27 +298,27 @@ TEST (network, send_insufficient_work)
auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
nano::publish publish1 (block1); nano::publish publish1 (block1);
auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ()))); auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ())));
tcp_channel->send (publish1, [](boost::system::error_code const & ec, size_t size) {}); tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work between epoch_2_recieve & epoch_1 // Legacy block work between epoch_2_recieve & epoch_1
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish2 (block2); nano::publish publish2 (block2);
tcp_channel->send (publish2, [](boost::system::error_code const & ec, size_t size) {}); tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1);
ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work epoch_1 // Legacy block work epoch_1
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2))); auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2)));
nano::publish publish3 (block3); nano::publish publish3 (block3);
tcp_channel->send (publish3, [](boost::system::error_code const & ec, size_t size) {}); tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
// State block work epoch_2_recieve // State block work epoch_2_recieve
auto block4 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, block1->hash (), nano::dev_genesis_key.pub, 20, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); auto block4 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, block1->hash (), nano::dev_genesis_key.pub, 20, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish4 (block4); nano::publish publish4 (block4);
tcp_channel->send (publish4, [](boost::system::error_code const & ec, size_t size) {}); tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
@ -405,7 +405,7 @@ TEST (network, receive_weight_change)
system.wallet (1)->store.representative_set (transaction, key2.pub); system.wallet (1)->store.representative_set (transaction, key2.pub);
} }
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ()));
ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr<nano::node> const & node_a) { return node_a->weight (key2.pub) == system.nodes[0]->config.receive_minimum.number (); })); ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr<nano::node> const & node_a) { return node_a->weight (key2.pub) == system.nodes[0]->config.receive_minimum.number (); }));
} }
TEST (parse_endpoint, valid) TEST (parse_endpoint, valid)
@ -496,7 +496,7 @@ TEST (network, ipv6_bind_send_ipv4)
auto finish1 (false); auto finish1 (false);
nano::endpoint endpoint3; nano::endpoint endpoint3;
boost::asio::ip::udp::socket socket1 (io_ctx, endpoint1); boost::asio::ip::udp::socket socket1 (io_ctx, endpoint1);
socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1](boost::system::error_code const & error, size_t size_a) { socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1] (boost::system::error_code const & error, size_t size_a) {
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (16, size_a); ASSERT_EQ (16, size_a);
finish1 = true; finish1 = true;
@ -504,7 +504,7 @@ TEST (network, ipv6_bind_send_ipv4)
boost::asio::ip::udp::socket socket2 (io_ctx, endpoint2); boost::asio::ip::udp::socket socket2 (io_ctx, endpoint2);
nano::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), port1); nano::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), port1);
nano::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), port2); nano::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), port2);
socket2.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint5, [](boost::system::error_code const & error, size_t size_a) { socket2.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint5, [] (boost::system::error_code const & error, size_t size_a) {
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (16, size_a); ASSERT_EQ (16, size_a);
}); });
@ -518,11 +518,11 @@ TEST (network, ipv6_bind_send_ipv4)
ASSERT_EQ (endpoint6, endpoint3); ASSERT_EQ (endpoint6, endpoint3);
std::array<uint8_t, 16> bytes2; std::array<uint8_t, 16> bytes2;
nano::endpoint endpoint4; nano::endpoint endpoint4;
socket2.async_receive_from (boost::asio::buffer (bytes2.data (), bytes2.size ()), endpoint4, [](boost::system::error_code const & error, size_t size_a) { socket2.async_receive_from (boost::asio::buffer (bytes2.data (), bytes2.size ()), endpoint4, [] (boost::system::error_code const & error, size_t size_a) {
ASSERT_FALSE (!error); ASSERT_FALSE (!error);
ASSERT_EQ (16, size_a); ASSERT_EQ (16, size_a);
}); });
socket1.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint6, [](boost::system::error_code const & error, size_t size_a) { socket1.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint6, [] (boost::system::error_code const & error, size_t size_a) {
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (16, size_a); ASSERT_EQ (16, size_a);
}); });
@ -635,7 +635,7 @@ TEST (message_buffer_manager, one_buffer_multithreaded)
{ {
nano::stat stats; nano::stat stats;
nano::message_buffer_manager buffer (stats, 512, 1); nano::message_buffer_manager buffer (stats, 512, 1);
boost::thread thread ([&buffer]() { boost::thread thread ([&buffer] () {
auto done (false); auto done (false);
while (!done) while (!done)
{ {
@ -663,7 +663,7 @@ TEST (message_buffer_manager, many_buffers_multithreaded)
std::vector<boost::thread> threads; std::vector<boost::thread> threads;
for (auto i (0); i < 4; ++i) for (auto i (0); i < 4; ++i)
{ {
threads.push_back (boost::thread ([&buffer]() { threads.push_back (boost::thread ([&buffer] () {
auto done (false); auto done (false);
while (!done) while (!done)
{ {
@ -679,7 +679,7 @@ TEST (message_buffer_manager, many_buffers_multithreaded)
std::atomic_int count (0); std::atomic_int count (0);
for (auto i (0); i < 4; ++i) for (auto i (0); i < 4; ++i)
{ {
threads.push_back (boost::thread ([&buffer, &count]() { threads.push_back (boost::thread ([&buffer, &count] () {
auto done (false); auto done (false);
for (auto i (0); !done && i < 1000; ++i) for (auto i (0); !done && i < 1000; ++i)
{ {
@ -723,9 +723,9 @@ TEST (tcp_listener, tcp_node_id_handshake)
nano::node_id_handshake node_id_handshake (cookie, boost::none); nano::node_id_handshake node_id_handshake (cookie, boost::none);
auto input (node_id_handshake.to_shared_const_buffer ()); auto input (node_id_handshake.to_shared_const_buffer ());
std::atomic<bool> write_done (false); std::atomic<bool> write_done (false);
socket->async_connect (bootstrap_endpoint, [&input, socket, &write_done](boost::system::error_code const & ec) { socket->async_connect (bootstrap_endpoint, [&input, socket, &write_done] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
socket->async_write (input, [&input, &write_done](boost::system::error_code const & ec, size_t size_a) { socket->async_write (input, [&input, &write_done] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (input.size (), size_a); ASSERT_EQ (input.size (), size_a);
write_done = true; write_done = true;
@ -738,7 +738,7 @@ TEST (tcp_listener, tcp_node_id_handshake)
nano::node_id_handshake node_id_handshake_response (boost::none, response_zero); nano::node_id_handshake node_id_handshake_response (boost::none, response_zero);
auto output (node_id_handshake_response.to_bytes ()); auto output (node_id_handshake_response.to_bytes ());
std::atomic<bool> done (false); std::atomic<bool> done (false);
socket->async_read (output, output->size (), [&output, &done](boost::system::error_code const & ec, size_t size_a) { socket->async_read (output, output->size (), [&output, &done] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (output->size (), size_a); ASSERT_EQ (output->size (), size_a);
done = true; done = true;
@ -752,7 +752,7 @@ TEST (tcp_listener, tcp_listener_timeout_empty)
auto node0 (system.nodes[0]); auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::socket> (*node0)); auto socket (std::make_shared<nano::socket> (*node0));
std::atomic<bool> connected (false); std::atomic<bool> connected (false);
socket->async_connect (node0->bootstrap.endpoint (), [&connected](boost::system::error_code const & ec) { socket->async_connect (node0->bootstrap.endpoint (), [&connected] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
connected = true; connected = true;
}); });
@ -777,9 +777,9 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake)
auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->bootstrap.endpoint ()))); auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->bootstrap.endpoint ())));
nano::node_id_handshake node_id_handshake (cookie, boost::none); nano::node_id_handshake node_id_handshake (cookie, boost::none);
auto input (node_id_handshake.to_shared_const_buffer ()); auto input (node_id_handshake.to_shared_const_buffer ());
socket->async_connect (node0->bootstrap.endpoint (), [&input, socket](boost::system::error_code const & ec) { socket->async_connect (node0->bootstrap.endpoint (), [&input, socket] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
socket->async_write (input, [&input](boost::system::error_code const & ec, size_t size_a) { socket->async_write (input, [&input] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (input.size (), size_a); ASSERT_EQ (input.size (), size_a);
}); });
@ -818,7 +818,7 @@ TEST (network, replace_port)
auto wrong_endpoint = nano::endpoint (node1->network.endpoint ().address (), nano::get_available_port ()); auto wrong_endpoint = nano::endpoint (node1->network.endpoint ().address (), nano::get_available_port ());
auto channel0 (node0->network.udp_channels.insert (wrong_endpoint, node1->network_params.protocol.protocol_version)); auto channel0 (node0->network.udp_channels.insert (wrong_endpoint, node1->network_params.protocol.protocol_version));
ASSERT_NE (nullptr, channel0); ASSERT_NE (nullptr, channel0);
node0->network.udp_channels.modify (channel0, [&node1](std::shared_ptr<nano::transport::channel> const & channel_a) { node0->network.udp_channels.modify (channel0, [&node1] (std::shared_ptr<nano::transport::channel> const & channel_a) {
channel_a->set_node_id (node1->node_id.pub); channel_a->set_node_id (node1->node_id.pub);
}); });
auto peers_list (node0->network.list (std::numeric_limits<size_t>::max ())); auto peers_list (node0->network.list (std::numeric_limits<size_t>::max ()));
@ -960,7 +960,7 @@ TEST (peer_exclusion, validate)
nano::tcp_endpoint oldest (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x0)), 0); nano::tcp_endpoint oldest (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x0)), 0);
ASSERT_EQ (peers_by_endpoint.end (), peers_by_endpoint.find (oldest.address ())); ASSERT_EQ (peers_by_endpoint.end (), peers_by_endpoint.find (oldest.address ()));
auto to_seconds = [](std::chrono::steady_clock::time_point const & timepoint) { auto to_seconds = [] (std::chrono::steady_clock::time_point const & timepoint) {
return static_cast<double> (std::chrono::duration_cast<std::chrono::seconds> (timepoint.time_since_epoch ()).count ()); return static_cast<double> (std::chrono::duration_cast<std::chrono::seconds> (timepoint.time_since_epoch ()).count ());
}; };
nano::tcp_endpoint first (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x1)), 0); nano::tcp_endpoint first (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x1)), 0);
@ -1117,7 +1117,7 @@ TEST (network, cleanup_purge)
ASSERT_EQ (0, node1.network.size ()); ASSERT_EQ (0, node1.network.size ());
std::weak_ptr<nano::node> node_w = node1.shared (); std::weak_ptr<nano::node> node_w = node1.shared ();
node1.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w](std::shared_ptr<nano::transport::channel> const & channel_a) { node1.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w] (std::shared_ptr<nano::transport::channel> const & channel_a) {
if (auto node_l = node_w.lock ()) if (auto node_l = node_w.lock ())
{ {
node_l->network.send_keepalive (channel_a); node_l->network.send_keepalive (channel_a);

2
nano/core_test/network_filter.cpp
View file

@ -10,7 +10,7 @@ TEST (network_filter, unit)
{ {
nano::genesis genesis; nano::genesis genesis;
nano::network_filter filter (1); nano::network_filter filter (1);
auto one_block = [&filter](std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) { auto one_block = [&filter] (std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) {
nano::publish message (block_a); nano::publish message (block_a);
auto bytes (message.to_bytes ()); auto bytes (message.to_bytes ());
nano::bufferstream stream (bytes->data (), bytes->size ()); nano::bufferstream stream (bytes->data (), bytes->size ());

2194
nano/core_test/node.cpp
View file

File diff suppressed because it is too large Load diff

20
nano/core_test/peer_container.cpp
View file

@ -20,8 +20,8 @@ TEST (peer_container, no_recontact)
auto observed_disconnect (false); auto observed_disconnect (false);
nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 10000); nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 10000);
ASSERT_EQ (0, network.size ()); ASSERT_EQ (0, network.size ());
network.channel_observer = [&observed_peer](std::shared_ptr<nano::transport::channel> const &) { ++observed_peer; }; network.channel_observer = [&observed_peer] (std::shared_ptr<nano::transport::channel> const &) { ++observed_peer; };
node1.network.disconnect_observer = [&observed_disconnect]() { observed_disconnect = true; }; node1.network.disconnect_observer = [&observed_disconnect] () { observed_disconnect = true; };
auto channel (network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version)); auto channel (network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version));
ASSERT_EQ (1, network.size ()); ASSERT_EQ (1, network.size ());
ASSERT_EQ (channel, network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version)); ASSERT_EQ (channel, network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version));
@ -61,12 +61,12 @@ TEST (peer_container, split)
nano::endpoint endpoint2 (boost::asio::ip::address_v6::loopback (), 101); nano::endpoint endpoint2 (boost::asio::ip::address_v6::loopback (), 101);
auto channel1 (node1.network.udp_channels.insert (endpoint1, 0)); auto channel1 (node1.network.udp_channels.insert (endpoint1, 0));
ASSERT_NE (nullptr, channel1); ASSERT_NE (nullptr, channel1);
node1.network.udp_channels.modify (channel1, [&now](auto channel) { node1.network.udp_channels.modify (channel1, [&now] (auto channel) {
channel->set_last_packet_received (now - std::chrono::seconds (1)); channel->set_last_packet_received (now - std::chrono::seconds (1));
}); });
auto channel2 (node1.network.udp_channels.insert (endpoint2, 0)); auto channel2 (node1.network.udp_channels.insert (endpoint2, 0));
ASSERT_NE (nullptr, channel2); ASSERT_NE (nullptr, channel2);
node1.network.udp_channels.modify (channel2, [&now](auto channel) { node1.network.udp_channels.modify (channel2, [&now] (auto channel) {
channel->set_last_packet_received (now + std::chrono::seconds (1)); channel->set_last_packet_received (now + std::chrono::seconds (1));
}); });
ASSERT_EQ (2, node1.network.size ()); ASSERT_EQ (2, node1.network.size ());
@ -84,7 +84,7 @@ TEST (channels, fill_random_clear)
std::array<nano::endpoint, 8> target; std::array<nano::endpoint, 8> target;
std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
system.nodes[0]->network.random_fill (target); system.nodes[0]->network.random_fill (target);
ASSERT_TRUE (std::all_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); })); ASSERT_TRUE (std::all_of (target.begin (), target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
} }
TEST (channels, fill_random_full) TEST (channels, fill_random_full)
@ -97,7 +97,7 @@ TEST (channels, fill_random_full)
std::array<nano::endpoint, 8> target; std::array<nano::endpoint, 8> target;
std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
system.nodes[0]->network.random_fill (target); system.nodes[0]->network.random_fill (target);
ASSERT_TRUE (std::none_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); ASSERT_TRUE (std::none_of (target.begin (), target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
} }
TEST (channels, fill_random_part) TEST (channels, fill_random_part)
@ -111,9 +111,9 @@ TEST (channels, fill_random_part)
} }
std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
system.nodes[0]->network.random_fill (target); system.nodes[0]->network.random_fill (target);
ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 0); })); ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 0); }));
ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); })); ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
} }
TEST (peer_container, list_fanout) TEST (peer_container, list_fanout)
@ -125,7 +125,7 @@ TEST (peer_container, list_fanout)
ASSERT_EQ (0, node.network.fanout ()); ASSERT_EQ (0, node.network.fanout ());
auto list1 (node.network.list (node.network.fanout ())); auto list1 (node.network.list (node.network.fanout ()));
ASSERT_TRUE (list1.empty ()); ASSERT_TRUE (list1.empty ());
auto add_peer = [&node](const uint16_t port_a) { auto add_peer = [&node] (const uint16_t port_a) {
ASSERT_NE (nullptr, node.network.udp_channels.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), port_a), node.network_params.protocol.protocol_version)); ASSERT_NE (nullptr, node.network.udp_channels.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), port_a), node.network_params.protocol.protocol_version));
}; };
add_peer (9998); add_peer (9998);

1
nano/core_test/processor_service.cpp
View file

@ -7,7 +7,6 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
TEST (processor_service, bad_send_signature) TEST (processor_service, bad_send_signature)
{ {
nano::logger_mt logger; nano::logger_mt logger;

144
nano/core_test/request_aggregator.cpp
View file

@ -53,37 +53,37 @@ TEST (request_aggregator, one_update)
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::keypair key1; nano::keypair key1;
auto send1 = nano::state_block_builder () auto send1 = nano::state_block_builder ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio) .balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node.work_generate_blocking (genesis.hash ())) .work (*node.work_generate_blocking (genesis.hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
node.confirmation_height_processor.add (send1); node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder () auto send2 = nano::state_block_builder ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (send1->hash ()) .previous (send1->hash ())
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio) .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ())) .work (*node.work_generate_blocking (send1->hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
auto receive1 = nano::state_block_builder () auto receive1 = nano::state_block_builder ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::Gxrb_ratio) .balance (nano::Gxrb_ratio)
.link (send1->hash ()) .link (send1->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub)) .work (*node.work_generate_blocking (key1.pub))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (send2->hash (), send2->root ());
@ -120,35 +120,35 @@ TEST (request_aggregator, two)
nano::keypair key1; nano::keypair key1;
nano::state_block_builder builder; nano::state_block_builder builder;
auto send1 = builder.make_block () auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (genesis.hash ()) .previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1) .balance (nano::genesis_amount - 1)
.link (key1.pub) .link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node.work_generate_blocking (genesis.hash ())) .work (*node.work_generate_blocking (genesis.hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
node.confirmation_height_processor.add (send1); node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (send1->hash ()) .previous (send1->hash ())
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2) .balance (nano::genesis_amount - 2)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ())) .work (*node.work_generate_blocking (send1->hash ()))
.build_shared (); .build_shared ();
auto receive1 = builder.make_block () auto receive1 = builder.make_block ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (1) .balance (1)
.link (send1->hash ()) .link (send1->hash ())
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub)) .work (*node.work_generate_blocking (key1.pub))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
@ -234,15 +234,15 @@ TEST (request_aggregator, split)
{ {
nano::block_builder builder; nano::block_builder builder;
blocks.push_back (builder blocks.push_back (builder
.state () .state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (previous) .previous (previous)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - (i + 1)) .balance (nano::genesis_amount - (i + 1))
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (previous)) .work (*system.work.generate (previous))
.build ()); .build ());
auto const & block = blocks.back (); auto const & block = blocks.back ();
previous = block->hash (); previous = block->hash ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *block).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *block).code);
@ -374,21 +374,21 @@ TEST (request_aggregator, cannot_vote)
nano::genesis genesis; nano::genesis genesis;
nano::state_block_builder builder; nano::state_block_builder builder;
auto send1 = builder.make_block () auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1) .balance (nano::genesis_amount - 1)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.from (*send1) .from (*send1)
.previous (send1->hash ()) .previous (send1->hash ())
.balance (send1->balance ().number () - 1) .balance (send1->balance ().number () - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);

12
nano/core_test/signing.cpp
View file

@ -38,7 +38,7 @@ TEST (signature_checker, bulk_single_thread)
} }
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check); checker.verify (check);
bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [](auto verification) { return verification == 1; }); bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [] (auto verification) { return verification == 1; });
ASSERT_TRUE (all_valid); ASSERT_TRUE (all_valid);
} }
@ -46,7 +46,7 @@ TEST (signature_checker, many_multi_threaded)
{ {
nano::signature_checker checker (4); nano::signature_checker checker (4);
auto signature_checker_work_func = [&checker]() { auto signature_checker_work_func = [&checker] () {
nano::keypair key; nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
auto block_hash = block.hash (); auto block_hash = block.hash ();
@ -97,7 +97,7 @@ TEST (signature_checker, many_multi_threaded)
checker.verify (signature_checker_sets[i]); checker.verify (signature_checker_sets[i]);
// Confirm all but last are valid // Confirm all but last are valid
auto all_valid = std::all_of (verifications[i].cbegin (), verifications[i].cend () - 1, [](auto verification) { return verification == 1; }); auto all_valid = std::all_of (verifications[i].cbegin (), verifications[i].cend () - 1, [] (auto verification) { return verification == 1; });
ASSERT_TRUE (all_valid); ASSERT_TRUE (all_valid);
ASSERT_EQ (verifications[i][last_signature_index], 0); ASSERT_EQ (verifications[i][last_signature_index], 0);
} }
@ -114,7 +114,7 @@ TEST (signature_checker, one)
{ {
nano::signature_checker checker (0); nano::signature_checker checker (0);
auto verify_block = [&checker](auto & block, auto result) { auto verify_block = [&checker] (auto & block, auto result) {
std::vector<nano::uint256_union> hashes; std::vector<nano::uint256_union> hashes;
std::vector<unsigned char const *> messages; std::vector<unsigned char const *> messages;
std::vector<size_t> lengths; std::vector<size_t> lengths;
@ -152,7 +152,7 @@ TEST (signature_checker, boundary_checks)
{ {
// sizes container must be in incrementing order // sizes container must be in incrementing order
std::vector<size_t> sizes{ 0, 1 }; std::vector<size_t> sizes{ 0, 1 };
auto add_boundary = [&sizes](size_t boundary) { auto add_boundary = [&sizes] (size_t boundary) {
sizes.insert (sizes.end (), { boundary - 1, boundary, boundary + 1 }); sizes.insert (sizes.end (), { boundary - 1, boundary, boundary + 1 });
}; };
@ -194,7 +194,7 @@ TEST (signature_checker, boundary_checks)
} }
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check); checker.verify (check);
bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [](auto verification) { return verification == 1; }); bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [] (auto verification) { return verification == 1; });
ASSERT_TRUE (all_valid); ASSERT_TRUE (all_valid);
last_size = size; last_size = size;
} }

18
nano/core_test/socket.cpp
View file

@ -18,7 +18,7 @@ TEST (socket, drop_policy)
std::vector<std::shared_ptr<nano::socket>> connections; std::vector<std::shared_ptr<nano::socket>> connections;
auto func = [&](size_t total_message_count, nano::buffer_drop_policy drop_policy) { auto func = [&] (size_t total_message_count, nano::buffer_drop_policy drop_policy) {
auto server_port (nano::get_available_port ()); auto server_port (nano::get_available_port ());
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port);
@ -28,7 +28,7 @@ TEST (socket, drop_policy)
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// Accept connection, but don't read so the writer will drop. // Accept connection, but don't read so the writer will drop.
server_socket->on_connection ([&connections](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&connections] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
connections.push_back (new_connection); connections.push_back (new_connection);
return true; return true;
}); });
@ -38,12 +38,12 @@ TEST (socket, drop_policy)
nano::util::counted_completion write_completion (static_cast<unsigned> (total_message_count)); nano::util::counted_completion write_completion (static_cast<unsigned> (total_message_count));
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::loopback (), server_port), client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::loopback (), server_port),
[&channel, total_message_count, node, &write_completion, &drop_policy, client](boost::system::error_code const & ec_a) mutable { [&channel, total_message_count, node, &write_completion, &drop_policy, client] (boost::system::error_code const & ec_a) mutable {
for (int i = 0; i < total_message_count; i++) for (int i = 0; i < total_message_count; i++)
{ {
std::vector<uint8_t> buff (1); std::vector<uint8_t> buff (1);
channel.send_buffer ( channel.send_buffer (
nano::shared_const_buffer (std::move (buff)), [&write_completion, client](boost::system::error_code const & ec, size_t size_a) mutable { nano::shared_const_buffer (std::move (buff)), [&write_completion, client] (boost::system::error_code const & ec, size_t size_a) mutable {
client.reset (); client.reset ();
write_completion.increment (); write_completion.increment ();
}, },
@ -88,7 +88,7 @@ TEST (socket, concurrent_writes)
// We're expecting client_count*4 messages // We're expecting client_count*4 messages
nano::util::counted_completion read_count_completion (total_message_count); nano::util::counted_completion read_count_completion (total_message_count);
std::function<void(std::shared_ptr<nano::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader](std::shared_ptr<nano::socket> const & socket_a) { std::function<void (std::shared_ptr<nano::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr<nano::socket> const & socket_a) {
auto buff (std::make_shared<std::vector<uint8_t>> ()); auto buff (std::make_shared<std::vector<uint8_t>> ());
buff->resize (1); buff->resize (1);
#ifndef _WIN32 #ifndef _WIN32
@ -100,7 +100,7 @@ TEST (socket, concurrent_writes)
#endif #endif
#endif #endif
#endif #endif
socket_a->async_read (buff, 1, [&read_count_completion, &reader, &total_message_count, socket_a, buff](boost::system::error_code const & ec, size_t size_a) { socket_a->async_read (buff, 1, [&read_count_completion, &reader, &total_message_count, socket_a, buff] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
if (read_count_completion.increment () < total_message_count) if (read_count_completion.increment () < total_message_count)
@ -127,7 +127,7 @@ TEST (socket, concurrent_writes)
std::vector<std::shared_ptr<nano::socket>> connections; std::vector<std::shared_ptr<nano::socket>> connections;
// On every new connection, start reading data // On every new connection, start reading data
server_socket->on_connection ([&connections, &reader](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&connections, &reader] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
if (ec_a) if (ec_a)
{ {
std::cerr << "on_connection: " << ec_a.message () << std::endl; std::cerr << "on_connection: " << ec_a.message () << std::endl;
@ -148,7 +148,7 @@ TEST (socket, concurrent_writes)
auto client = std::make_shared<nano::socket> (*node, boost::none); auto client = std::make_shared<nano::socket> (*node, boost::none);
clients.push_back (client); clients.push_back (client);
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000), client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000),
[&connection_count_completion](boost::system::error_code const & ec_a) { [&connection_count_completion] (boost::system::error_code const & ec_a) {
if (ec_a) if (ec_a)
{ {
std::cerr << "async_connect: " << ec_a.message () << std::endl; std::cerr << "async_connect: " << ec_a.message () << std::endl;
@ -175,7 +175,7 @@ TEST (socket, concurrent_writes)
#endif #endif
#endif #endif
#endif #endif
client_threads.emplace_back ([&client, &message_count]() { client_threads.emplace_back ([&client, &message_count] () {
for (int i = 0; i < message_count; i++) for (int i = 0; i < message_count; i++)
{ {
std::vector<uint8_t> buff; std::vector<uint8_t> buff;

38
nano/core_test/telemetry.cpp
View file

@ -242,7 +242,7 @@ TEST (telemetry, basic)
auto channel = node_client->network.find_channel (node_server->network.endpoint ()); auto channel = node_client->network.find_channel (node_server->network.endpoint ());
{ {
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data] (nano::telemetry_data_response const & response_a) {
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
ASSERT_EQ (server_endpoint, response_a.endpoint); ASSERT_EQ (server_endpoint, response_a.endpoint);
telemetry_data = response_a.telemetry_data; telemetry_data = response_a.telemetry_data;
@ -258,7 +258,7 @@ TEST (telemetry, basic)
// Call again straight away. It should use the cache // Call again straight away. It should use the cache
{ {
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data] (nano::telemetry_data_response const & response_a) {
ASSERT_EQ (telemetry_data, response_a.telemetry_data); ASSERT_EQ (telemetry_data, response_a.telemetry_data);
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
done = true; done = true;
@ -271,7 +271,7 @@ TEST (telemetry, basic)
std::this_thread::sleep_for (nano::telemetry_cache_cutoffs::dev); std::this_thread::sleep_for (nano::telemetry_cache_cutoffs::dev);
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data] (nano::telemetry_data_response const & response_a) {
ASSERT_NE (telemetry_data, response_a.telemetry_data); ASSERT_NE (telemetry_data, response_a.telemetry_data);
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
done = true; done = true;
@ -303,7 +303,7 @@ TEST (telemetry, over_udp)
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto channel = node_client->network.find_channel (node_server->network.endpoint ()); auto channel = node_client->network.find_channel (node_server->network.endpoint ());
node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &node_server](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &node_server] (nano::telemetry_data_response const & response_a) {
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_server->network_params, node_server->config.bandwidth_limit, node_server->active.active_difficulty (), node_server->node_id); nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_server->network_params, node_server->config.bandwidth_limit, node_server->active.active_difficulty (), node_server->node_id);
done = true; done = true;
@ -330,7 +330,7 @@ TEST (telemetry, invalid_channel)
auto node_server = system.nodes.back (); auto node_server = system.nodes.back ();
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (nullptr, [&done](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (nullptr, [&done] (nano::telemetry_data_response const & response_a) {
ASSERT_TRUE (response_a.error); ASSERT_TRUE (response_a.error);
done = true; done = true;
}); });
@ -349,9 +349,9 @@ TEST (telemetry, blocking_request)
// Request telemetry metrics // Request telemetry metrics
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
std::function<void()> call_system_poll; std::function<void ()> call_system_poll;
std::promise<void> promise; std::promise<void> promise;
call_system_poll = [&call_system_poll, &workers = node_client->workers, &done, &system, &promise]() { call_system_poll = [&call_system_poll, &workers = node_client->workers, &done, &system, &promise] () {
if (!done) if (!done)
{ {
ASSERT_NO_ERROR (system.poll ()); ASSERT_NO_ERROR (system.poll ());
@ -392,7 +392,7 @@ TEST (telemetry, disconnects)
ASSERT_TRUE (channel); ASSERT_TRUE (channel);
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done] (nano::telemetry_data_response const & response_a) {
ASSERT_TRUE (response_a.error); ASSERT_TRUE (response_a.error);
done = true; done = true;
}); });
@ -414,7 +414,7 @@ TEST (telemetry, dos_tcp)
nano::telemetry_req message; nano::telemetry_req message;
auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
channel->send (message, [](boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
}); });
@ -423,7 +423,7 @@ TEST (telemetry, dos_tcp)
auto orig = std::chrono::steady_clock::now (); auto orig = std::chrono::steady_clock::now ();
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
{ {
channel->send (message, [](boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
}); });
} }
@ -457,7 +457,7 @@ TEST (telemetry, dos_udp)
nano::telemetry_req message; nano::telemetry_req message;
auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ())); auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ()));
channel->send (message, [](boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
}); });
@ -466,7 +466,7 @@ TEST (telemetry, dos_udp)
auto orig = std::chrono::steady_clock::now (); auto orig = std::chrono::steady_clock::now ();
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
{ {
channel->send (message, [](boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
}); });
} }
@ -501,7 +501,7 @@ TEST (telemetry, disable_metrics)
ASSERT_TRUE (channel); ASSERT_TRUE (channel);
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done] (nano::telemetry_data_response const & response_a) {
ASSERT_TRUE (response_a.error); ASSERT_TRUE (response_a.error);
done = true; done = true;
}); });
@ -511,7 +511,7 @@ TEST (telemetry, disable_metrics)
// It should still be able to receive metrics though // It should still be able to receive metrics though
done = false; done = false;
auto channel1 = node_server->network.find_channel (node_client->network.endpoint ()); auto channel1 = node_server->network.find_channel (node_client->network.endpoint ());
node_server->telemetry->get_metrics_single_peer_async (channel1, [&done, node_client](nano::telemetry_data_response const & response_a) { node_server->telemetry->get_metrics_single_peer_async (channel1, [&done, node_client] (nano::telemetry_data_response const & response_a) {
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_client->network_params, node_client->config.bandwidth_limit, node_client->active.active_difficulty (), node_client->node_id); nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_client->network_params, node_client->config.bandwidth_limit, node_client->active.active_difficulty (), node_client->node_id);
done = true; done = true;
@ -536,7 +536,7 @@ TEST (telemetry, max_possible_size)
wait_peer_connections (system); wait_peer_connections (system);
auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
channel->send (message, [](boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
}); });
@ -596,11 +596,11 @@ TEST (telemetry, remove_peer_different_genesis_udp)
std::atomic<bool> done0{ false }; std::atomic<bool> done0{ false };
std::atomic<bool> done1{ false }; std::atomic<bool> done1{ false };
node0->telemetry->get_metrics_single_peer_async (channel1, [&done0](nano::telemetry_data_response const & response_a) { node0->telemetry->get_metrics_single_peer_async (channel1, [&done0] (nano::telemetry_data_response const & response_a) {
done0 = true; done0 = true;
}); });
node1->telemetry->get_metrics_single_peer_async (channel0, [&done1](nano::telemetry_data_response const & response_a) { node1->telemetry->get_metrics_single_peer_async (channel0, [&done1] (nano::telemetry_data_response const & response_a) {
done1 = true; done1 = true;
}); });
@ -635,7 +635,7 @@ TEST (telemetry, remove_peer_invalid_signature)
node->network.process_message (telemetry_ack, channel); node->network.process_message (telemetry_ack, channel);
ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0); ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0);
ASSERT_NO_ERROR (system.poll_until_true (3s, [&node, address = channel->get_endpoint ().address ()]() -> bool { ASSERT_NO_ERROR (system.poll_until_true (3s, [&node, address = channel->get_endpoint ().address ()] () -> bool {
nano::lock_guard<nano::mutex> guard (node->network.excluded_peers.mutex); nano::lock_guard<nano::mutex> guard (node->network.excluded_peers.mutex);
return node->network.excluded_peers.peers.get<nano::peer_exclusion::tag_endpoint> ().count (address); return node->network.excluded_peers.peers.get<nano::peer_exclusion::tag_endpoint> ().count (address);
})); }));
@ -662,7 +662,7 @@ TEST (telemetry, maker_pruning)
auto channel = node_client->network.find_channel (node_server->network.endpoint ()); auto channel = node_client->network.find_channel (node_server->network.endpoint ());
{ {
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data](nano::telemetry_data_response const & response_a) { node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data] (nano::telemetry_data_response const & response_a) {
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
ASSERT_EQ (server_endpoint, response_a.endpoint); ASSERT_EQ (server_endpoint, response_a.endpoint);
telemetry_data = response_a.telemetry_data; telemetry_data = response_a.telemetry_data;

14
nano/core_test/utility.cpp
View file

@ -95,7 +95,7 @@ TEST (thread, thread_pool)
{ {
std::atomic<bool> passed_sleep{ false }; std::atomic<bool> passed_sleep{ false };
auto func = [&passed_sleep]() { auto func = [&passed_sleep] () {
std::this_thread::sleep_for (std::chrono::seconds (1)); std::this_thread::sleep_for (std::chrono::seconds (1));
passed_sleep = true; passed_sleep = true;
}; };
@ -122,7 +122,7 @@ TEST (thread_pool_alarm, one)
std::atomic<bool> done (false); std::atomic<bool> done (false);
nano::mutex mutex; nano::mutex mutex;
nano::condition_variable condition; nano::condition_variable condition;
workers.add_timed_task (std::chrono::steady_clock::now (), [&]() { workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
{ {
nano::lock_guard<nano::mutex> lock (mutex); nano::lock_guard<nano::mutex> lock (mutex);
done = true; done = true;
@ -130,7 +130,7 @@ TEST (thread_pool_alarm, one)
condition.notify_one (); condition.notify_one ();
}); });
nano::unique_lock<nano::mutex> unique (mutex); nano::unique_lock<nano::mutex> unique (mutex);
condition.wait (unique, [&]() { return !!done; }); condition.wait (unique, [&] () { return !!done; });
} }
TEST (thread_pool_alarm, many) TEST (thread_pool_alarm, many)
@ -141,7 +141,7 @@ TEST (thread_pool_alarm, many)
nano::condition_variable condition; nano::condition_variable condition;
for (auto i (0); i < 50; ++i) for (auto i (0); i < 50; ++i)
{ {
workers.add_timed_task (std::chrono::steady_clock::now (), [&]() { workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
{ {
nano::lock_guard<nano::mutex> lock (mutex); nano::lock_guard<nano::mutex> lock (mutex);
count += 1; count += 1;
@ -150,7 +150,7 @@ TEST (thread_pool_alarm, many)
}); });
} }
nano::unique_lock<nano::mutex> unique (mutex); nano::unique_lock<nano::mutex> unique (mutex);
condition.wait (unique, [&]() { return count == 50; }); condition.wait (unique, [&] () { return count == 50; });
} }
TEST (thread_pool_alarm, top_execution) TEST (thread_pool_alarm, top_execution)
@ -160,12 +160,12 @@ TEST (thread_pool_alarm, top_execution)
int value2 (0); int value2 (0);
nano::mutex mutex; nano::mutex mutex;
std::promise<bool> promise; std::promise<bool> promise;
workers.add_timed_task (std::chrono::steady_clock::now (), [&]() { workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
nano::lock_guard<nano::mutex> lock (mutex); nano::lock_guard<nano::mutex> lock (mutex);
value1 = 1; value1 = 1;
value2 = 1; value2 = 1;
}); });
workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [&]() { workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [&] () {
nano::lock_guard<nano::mutex> lock (mutex); nano::lock_guard<nano::mutex> lock (mutex);
value2 = 2; value2 = 2;
promise.set_value (false); promise.set_value (false);

48
nano/core_test/vote_processor.cpp
View file

@ -191,14 +191,14 @@ TEST (vote_processor, no_broadcast_local)
// Reduce the weight of genesis to 2x default min voting weight // Reduce the weight of genesis to 2x default min voting weight
nano::keypair key; nano::keypair key;
std::shared_ptr<nano::block> send = builder.state () std::shared_ptr<nano::block> send = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.balance (2 * node.config.vote_minimum.number ()) .balance (2 * node.config.vote_minimum.number ())
.link (key.pub) .link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub)); ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));
@ -228,14 +228,14 @@ TEST (vote_processor, no_broadcast_local)
ASSERT_FALSE (node.wallets.reps ().exists (nano::dev_genesis_key.pub)); ASSERT_FALSE (node.wallets.reps ().exists (nano::dev_genesis_key.pub));
std::shared_ptr<nano::block> send2 = builder.state () std::shared_ptr<nano::block> send2 = builder.state ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.previous (send->hash ()) .previous (send->hash ())
.balance (node.config.vote_minimum) .balance (node.config.vote_minimum)
.link (key.pub) .link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (send->hash ())) .work (*system.work.generate (send->hash ()))
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send2).code); ASSERT_EQ (nano::process_result::progress, node.process_local (send2).code);
ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev_genesis_key.pub)); ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev_genesis_key.pub));
@ -257,14 +257,14 @@ TEST (vote_processor, no_broadcast_local)
// Repeat test with a PR in the wallet // Repeat test with a PR in the wallet
// Increase the genesis weight again // Increase the genesis weight again
std::shared_ptr<nano::block> open = builder.state () std::shared_ptr<nano::block> open = builder.state ()
.account (key.pub) .account (key.pub)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.previous (0) .previous (0)
.balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ()) .balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ())
.link (send->hash ()) .link (send->hash ())
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (open).code); ASSERT_EQ (nano::process_result::progress, node.process_local (open).code);
ASSERT_EQ (nano::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub)); ASSERT_EQ (nano::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));

70
nano/core_test/voting.cpp
View file

@ -66,7 +66,7 @@ TEST (vote_generator, cache)
ASSERT_TIMELY (1s, !node.history.votes (epoch1->root (), epoch1->hash ()).empty ()); ASSERT_TIMELY (1s, !node.history.votes (epoch1->root (), epoch1->hash ()).empty ());
auto votes (node.history.votes (epoch1->root (), epoch1->hash ())); auto votes (node.history.votes (epoch1->root (), epoch1->hash ()));
ASSERT_FALSE (votes.empty ()); ASSERT_FALSE (votes.empty ());
ASSERT_TRUE (std::any_of (votes[0]->begin (), votes[0]->end (), [hash = epoch1->hash ()](nano::block_hash const & hash_a) { return hash_a == hash; })); ASSERT_TRUE (std::any_of (votes[0]->begin (), votes[0]->end (), [hash = epoch1->hash ()] (nano::block_hash const & hash_a) { return hash_a == hash; }));
} }
TEST (vote_generator, multiple_representatives) TEST (vote_generator, multiple_representatives)
@ -97,7 +97,7 @@ TEST (vote_generator, multiple_representatives)
auto votes (node.history.votes (send->root (), send->hash ())); auto votes (node.history.votes (send->root (), send->hash ()));
for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev_genesis_key.pub }) for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev_genesis_key.pub })
{ {
auto existing (std::find_if (votes.begin (), votes.end (), [&account](std::shared_ptr<nano::vote> const & vote_a) -> bool { auto existing (std::find_if (votes.begin (), votes.end (), [&account] (std::shared_ptr<nano::vote> const & vote_a) -> bool {
return vote_a->account == account; return vote_a->account == account;
})); }));
ASSERT_NE (votes.end (), existing); ASSERT_NE (votes.end (), existing);
@ -110,7 +110,7 @@ TEST (vote_generator, session)
auto node (system.nodes[0]); auto node (system.nodes[0]);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::vote_generator_session generator_session (node->active.generator); nano::vote_generator_session generator_session (node->active.generator);
boost::thread thread ([node, &generator_session]() { boost::thread thread ([node, &generator_session] () {
nano::thread_role::set (nano::thread_role::name::request_loop); nano::thread_role::set (nano::thread_role::name::request_loop);
generator_session.add (nano::genesis_account, nano::genesis_hash); generator_session.add (nano::genesis_account, nano::genesis_hash);
ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate)); ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate));
@ -165,23 +165,23 @@ TEST (vote_spacing, vote_generator)
wallet.insert_adhoc (nano::dev_genesis_key.prv); wallet.insert_adhoc (nano::dev_genesis_key.prv);
nano::state_block_builder builder; nano::state_block_builder builder;
auto send1 = builder.make_block () auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio) .balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio - 1) .balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
node.active.generator.add (nano::genesis_hash, send1->hash ()); node.active.generator.add (nano::genesis_hash, send1->hash ());
@ -208,23 +208,23 @@ TEST (vote_spacing, rapid)
wallet.insert_adhoc (nano::dev_genesis_key.prv); wallet.insert_adhoc (nano::dev_genesis_key.prv);
nano::state_block_builder builder; nano::state_block_builder builder;
auto send1 = builder.make_block () auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio) .balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub) .account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub) .representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio - 1) .balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
.link (nano::dev_genesis_key.pub) .link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
node.active.generator.add (nano::genesis_hash, send1->hash ()); node.active.generator.add (nano::genesis_hash, send1->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);

30
nano/core_test/wallet.cpp
View file

@ -198,11 +198,11 @@ TEST (wallet, send_async)
nano::system system (1); nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::keypair key2; nano::keypair key2;
std::thread thread ([&system]() { std::thread thread ([&system] () {
ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev_genesis_key.pub).is_zero ()); ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev_genesis_key.pub).is_zero ());
}); });
std::atomic<bool> success (false); std::atomic<bool> success (false);
system.wallet (0)->send_async (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), [&success](std::shared_ptr<nano::block> const & block_a) { ASSERT_NE (nullptr, block_a); success = true; }); system.wallet (0)->send_async (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), [&success] (std::shared_ptr<nano::block> const & block_a) { ASSERT_NE (nullptr, block_a); success = true; });
thread.join (); thread.join ();
ASSERT_TIMELY (2s, success); ASSERT_TIMELY (2s, success);
} }
@ -846,7 +846,7 @@ TEST (wallet, password_race)
nano::system system (1); nano::system system (1);
nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
auto wallet = system.wallet (0); auto wallet = system.wallet (0);
std::thread thread ([&wallet]() { std::thread thread ([&wallet] () {
for (int i = 0; i < 100; i++) for (int i = 0; i < 100; i++)
{ {
auto transaction (wallet->wallets.tx_begin_write ()); auto transaction (wallet->wallets.tx_begin_write ());
@ -884,21 +884,21 @@ TEST (wallet, password_race_corrupt_seed)
std::vector<std::thread> threads; std::vector<std::thread> threads;
for (int i = 0; i < 100; i++) for (int i = 0; i < 100; i++)
{ {
threads.emplace_back ([&wallet]() { threads.emplace_back ([&wallet] () {
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++)
{ {
auto transaction (wallet->wallets.tx_begin_write ()); auto transaction (wallet->wallets.tx_begin_write ());
wallet->store.rekey (transaction, "0000"); wallet->store.rekey (transaction, "0000");
} }
}); });
threads.emplace_back ([&wallet]() { threads.emplace_back ([&wallet] () {
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++)
{ {
auto transaction (wallet->wallets.tx_begin_write ()); auto transaction (wallet->wallets.tx_begin_write ());
wallet->store.rekey (transaction, "1234"); wallet->store.rekey (transaction, "1234");
} }
}); });
threads.emplace_back ([&wallet]() { threads.emplace_back ([&wallet] () {
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++)
{ {
auto transaction (wallet->wallets.tx_begin_read ()); auto transaction (wallet->wallets.tx_begin_read ());
@ -1175,7 +1175,7 @@ TEST (wallet, foreach_representative_deadlock)
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
node.wallets.compute_reps (); node.wallets.compute_reps ();
ASSERT_EQ (1, node.wallets.reps ().voting); ASSERT_EQ (1, node.wallets.reps ().voting);
node.wallets.foreach_representative ([&node](nano::public_key const & pub, nano::raw_key const & prv) { node.wallets.foreach_representative ([&node] (nano::public_key const & pub, nano::raw_key const & prv) {
if (node.wallets.mutex.try_lock ()) if (node.wallets.mutex.try_lock ())
{ {
node.wallets.mutex.unlock (); node.wallets.mutex.unlock ();
@ -1201,14 +1201,14 @@ TEST (wallet, search_pending)
wallet.insert_adhoc (nano::dev_genesis_key.prv); wallet.insert_adhoc (nano::dev_genesis_key.prv);
nano::block_builder builder; nano::block_builder builder;
auto send = builder.state () auto send = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ()) .balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account) .link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build (); .build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code); ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
// Pending search should start an election // Pending search should start an election

16
nano/core_test/wallets.cpp
View file

@ -190,14 +190,14 @@ TEST (wallets, search_pending)
wallet->insert_adhoc (nano::dev_genesis_key.prv); wallet->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_builder builder; nano::block_builder builder;
auto send = builder.state () auto send = builder.state ()
.account (nano::genesis_account) .account (nano::genesis_account)
.previous (nano::genesis_hash) .previous (nano::genesis_hash)
.representative (nano::genesis_account) .representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ()) .balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account) .link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash)) .work (*system.work.generate (nano::genesis_hash))
.build (); .build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code); ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
// Pending search should start an election // Pending search should start an election

44
nano/core_test/websocket.cpp
View file

@ -28,7 +28,7 @@ TEST (websocket, subscription_edge)
ASSERT_EQ (0, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation)); ASSERT_EQ (0, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation));
auto task = ([config, &node1]() { auto task = ([config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -65,7 +65,7 @@ TEST (websocket, active_difficulty)
ASSERT_EQ (0, node1->websocket_server->subscriber_count (nano::websocket::topic::active_difficulty)); ASSERT_EQ (0, node1->websocket_server->subscriber_count (nano::websocket::topic::active_difficulty));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "active_difficulty", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "active_difficulty", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -129,7 +129,7 @@ TEST (websocket, confirmation)
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
std::atomic<bool> unsubscribed{ false }; std::atomic<bool> unsubscribed{ false };
auto task = ([&ack_ready, &unsubscribed, config, &node1]() { auto task = ([&ack_ready, &unsubscribed, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -186,7 +186,7 @@ TEST (websocket, stopped_election)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "stopped_election", "ack": "true"})json"); client.send_message (R"json({"action": "subscribe", "topic": "stopped_election", "ack": "true"})json");
client.await_ack (); client.await_ack ();
@ -229,7 +229,7 @@ TEST (websocket, confirmation_options)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task1 = ([&ack_ready, config, &node1]() { auto task1 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "accounts": ["xrb_invalid"]}})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "accounts": ["xrb_invalid"]}})json");
client.await_ack (); client.await_ack ();
@ -258,7 +258,7 @@ TEST (websocket, confirmation_options)
ASSERT_TIMELY (5s, future1.wait_for (0s) == std::future_status::ready); ASSERT_TIMELY (5s, future1.wait_for (0s) == std::future_status::ready);
ack_ready = false; ack_ready = false;
auto task2 = ([&ack_ready, config, &node1]() { auto task2 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "all_local_accounts": "true", "include_election_info": "true"}})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "all_local_accounts": "true", "include_election_info": "true"}})json");
client.await_ack (); client.await_ack ();
@ -309,7 +309,7 @@ TEST (websocket, confirmation_options)
} }
ack_ready = false; ack_ready = false;
auto task3 = ([&ack_ready, config, &node1]() { auto task3 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "all_local_accounts": "true"}})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "all_local_accounts": "true"}})json");
client.await_ack (); client.await_ack ();
@ -343,7 +343,7 @@ TEST (websocket, confirmation_options_votes)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task1 = ([&ack_ready, config, &node1]() { auto task1 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "include_election_info_with_votes": "true", "include_block": "false"}})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {"confirmation_type": "active_quorum", "include_election_info_with_votes": "true", "include_block": "false"}})json");
client.await_ack (); client.await_ack ();
@ -422,7 +422,7 @@ TEST (websocket, confirmation_options_update)
std::atomic<bool> added{ false }; std::atomic<bool> added{ false };
std::atomic<bool> deleted{ false }; std::atomic<bool> deleted{ false };
auto task = ([&added, &deleted, config, &node1]() { auto task = ([&added, &deleted, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
// Subscribe initially with empty options, everything will be filtered // Subscribe initially with empty options, everything will be filtered
client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {}})json"); client.send_message (R"json({"action": "subscribe", "topic": "confirmation", "ack": "true", "options": {}})json");
@ -477,7 +477,7 @@ TEST (websocket, vote)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -517,7 +517,7 @@ TEST (websocket, vote_options_type)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": true, "options": {"include_replays": "true", "include_indeterminate": "false"}})json"); client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": true, "options": {"include_replays": "true", "include_indeterminate": "false"}})json");
client.await_ack (); client.await_ack ();
@ -559,7 +559,7 @@ TEST (websocket, vote_options_representatives)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task1 = ([&ack_ready, config, &node1]() { auto task1 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ()); std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ());
client.send_message (message); client.send_message (message);
@ -583,7 +583,7 @@ TEST (websocket, vote_options_representatives)
auto balance = nano::genesis_amount; auto balance = nano::genesis_amount;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto send_amount = node1->online_reps.delta () + 1; auto send_amount = node1->online_reps.delta () + 1;
auto confirm_block = [&]() { auto confirm_block = [&] () {
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
balance -= send_amount; balance -= send_amount;
auto send (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, previous, nano::dev_genesis_key.pub, balance, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous))); auto send (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, previous, nano::dev_genesis_key.pub, balance, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous)));
@ -594,7 +594,7 @@ TEST (websocket, vote_options_representatives)
ASSERT_TIMELY (5s, future1.wait_for (0s) == std::future_status::ready); ASSERT_TIMELY (5s, future1.wait_for (0s) == std::future_status::ready);
ack_ready = false; ack_ready = false;
auto task2 = ([&ack_ready, config, &node1]() { auto task2 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["xrb_invalid"]}})json"); client.send_message (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["xrb_invalid"]}})json");
client.await_ack (); client.await_ack ();
@ -628,7 +628,7 @@ TEST (websocket, work)
// Subscribe to work and wait for response asynchronously // Subscribe to work and wait for response asynchronously
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "work", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "work", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -698,7 +698,7 @@ TEST (websocket, bootstrap)
// Subscribe to bootstrap and wait for response asynchronously // Subscribe to bootstrap and wait for response asynchronously
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "bootstrap", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "bootstrap", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -747,7 +747,7 @@ TEST (websocket, bootstrap_exited)
// Start bootstrap, exit after subscription // Start bootstrap, exit after subscription
std::atomic<bool> bootstrap_started{ false }; std::atomic<bool> bootstrap_started{ false };
nano::util::counted_completion subscribed_completion (1); nano::util::counted_completion subscribed_completion (1);
std::thread bootstrap_thread ([node1, &system, &bootstrap_started, &subscribed_completion]() { std::thread bootstrap_thread ([node1, &system, &bootstrap_started, &subscribed_completion] () {
std::shared_ptr<nano::bootstrap_attempt> attempt; std::shared_ptr<nano::bootstrap_attempt> attempt;
while (attempt == nullptr) while (attempt == nullptr)
{ {
@ -765,7 +765,7 @@ TEST (websocket, bootstrap_exited)
// Subscribe to bootstrap and wait for response asynchronously // Subscribe to bootstrap and wait for response asynchronously
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, &node1]() { auto task = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "bootstrap", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "bootstrap", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -809,7 +809,7 @@ TEST (websocket, ws_keepalive)
config.websocket_config.port = nano::get_available_port (); config.websocket_config.port = nano::get_available_port ();
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
auto task = ([config]() { auto task = ([config] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "ping"})json"); client.send_message (R"json({"action": "ping"})json");
client.await_ack (); client.await_ack ();
@ -838,7 +838,7 @@ TEST (websocket, telemetry)
wait_peer_connections (system); wait_peer_connections (system);
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto task = ([config = node1->config, &node1, &done]() { auto task = ([config = node1->config, &node1, &done] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "telemetry", "ack": true})json"); client.send_message (R"json({"action": "subscribe", "topic": "telemetry", "ack": true})json");
client.await_ack (); client.await_ack ();
@ -851,7 +851,7 @@ TEST (websocket, telemetry)
ASSERT_TIMELY (10s, done); ASSERT_TIMELY (10s, done);
node1->telemetry->get_metrics_single_peer_async (node1->network.find_channel (node2->network.endpoint ()), [](auto const & response_a) { node1->telemetry->get_metrics_single_peer_async (node1->network.find_channel (node2->network.endpoint ()), [] (auto const & response_a) {
ASSERT_FALSE (response_a.error); ASSERT_FALSE (response_a.error);
}); });
@ -888,7 +888,7 @@ TEST (websocket, new_unconfirmed_block)
auto node1 (system.add_node (config)); auto node1 (system.add_node (config));
std::atomic<bool> ack_ready{ false }; std::atomic<bool> ack_ready{ false };
auto task = ([&ack_ready, config, node1]() { auto task = ([&ack_ready, config, node1] () {
fake_websocket_client client (config.websocket_config.port); fake_websocket_client client (config.websocket_config.port);
client.send_message (R"json({"action": "subscribe", "topic": "new_unconfirmed_block", "ack": "true"})json"); client.send_message (R"json({"action": "subscribe", "topic": "new_unconfirmed_block", "ack": "true"})json");
client.await_ack (); client.await_ack ();

18
nano/core_test/work_pool.cpp
View file

@ -50,7 +50,7 @@ TEST (work, cancel)
{ {
nano::root key (1); nano::root key (1);
pool.generate ( pool.generate (
nano::work_version::work_1, key, nano::network_constants ().publish_thresholds.base, [&done](boost::optional<uint64_t> work_a) { nano::work_version::work_1, key, nano::network_constants ().publish_thresholds.base, [&done] (boost::optional<uint64_t> work_a) {
done = !work_a; done = !work_a;
}); });
pool.cancel (key); pool.cancel (key);
@ -69,12 +69,12 @@ TEST (work, cancel_many)
nano::root key5 (3); nano::root key5 (3);
nano::root key6 (1); nano::root key6 (1);
nano::network_constants constants; nano::network_constants constants;
pool.generate (nano::work_version::work_1, key1, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key1, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key2, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key2, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key3, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key3, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key4, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key4, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key5, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key5, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key6, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {}); pool.generate (nano::work_version::work_1, key6, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.cancel (key1); pool.cancel (key1);
} }
@ -93,7 +93,7 @@ TEST (work, opencl)
if (opencl != nullptr) if (opencl != nullptr)
{ {
// 0 threads, should add 1 for managing OpenCL // 0 threads, should add 1 for managing OpenCL
nano::work_pool pool (0, std::chrono::nanoseconds (0), [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) { nano::work_pool pool (0, std::chrono::nanoseconds (0), [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
return opencl->generate_work (version_a, root_a, difficulty_a); return opencl->generate_work (version_a, root_a, difficulty_a);
}); });
ASSERT_NE (nullptr, pool.opencl); ASSERT_NE (nullptr, pool.opencl);
@ -159,7 +159,7 @@ TEST (work, difficulty)
TEST (work, eco_pow) TEST (work, eco_pow)
{ {
auto work_func = [](std::promise<std::chrono::nanoseconds> & promise, std::chrono::nanoseconds interval) { auto work_func = [] (std::promise<std::chrono::nanoseconds> & promise, std::chrono::nanoseconds interval) {
nano::work_pool pool (1, interval); nano::work_pool pool (1, interval);
constexpr auto num_iterations = 5; constexpr auto num_iterations = 5;

2
nano/core_test/work_watcher.cpp
View file

@ -254,7 +254,7 @@ TEST (work_watcher, confirm_while_generating)
ASSERT_TIMELY (5s, 0 != node.work.size ()); ASSERT_TIMELY (5s, 0 != node.work.size ());
// Attach a callback to work cancellations // Attach a callback to work cancellations
std::atomic<bool> notified{ false }; std::atomic<bool> notified{ false };
node.observers.work_cancel.add ([&notified, &block1](nano::root const & root_a) { node.observers.work_cancel.add ([&notified, &block1] (nano::root const & root_a) {
EXPECT_EQ (root_a, block1->root ()); EXPECT_EQ (root_a, block1->root ());
notified = true; notified = true;
}); });

2
nano/ipc_flatbuffers_lib/flatbuffer_producer.cpp
View file

@ -6,7 +6,7 @@ nano::ipc::flatbuffer_producer::flatbuffer_producer ()
} }
nano::ipc::flatbuffer_producer::flatbuffer_producer (std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) : nano::ipc::flatbuffer_producer::flatbuffer_producer (std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) :
fbb (builder_a) fbb (builder_a)
{ {
} }

6
nano/ipc_flatbuffers_test/entry.cpp
View file

@ -16,7 +16,7 @@ namespace
void read_message_loop (std::shared_ptr<nano::ipc::ipc_client> const & connection) void read_message_loop (std::shared_ptr<nano::ipc::ipc_client> const & connection)
{ {
auto buffer (std::make_shared<std::vector<uint8_t>> ()); auto buffer (std::make_shared<std::vector<uint8_t>> ());
connection->async_read_message (buffer, std::chrono::seconds::max (), [buffer, connection](nano::error error_a, size_t size_a) { connection->async_read_message (buffer, std::chrono::seconds::max (), [buffer, connection] (nano::error error_a, size_t size_a) {
if (!error_a) if (!error_a)
{ {
auto verifier (flatbuffers::Verifier (buffer->data (), buffer->size ())); auto verifier (flatbuffers::Verifier (buffer->data (), buffer->size ()));
@ -57,11 +57,11 @@ int main (int argc, char * const * argv)
// be improved later to handle various options, including port and address. // be improved later to handle various options, including port and address.
std::string ipc_address = "::1"; std::string ipc_address = "::1";
uint16_t ipc_port = 7077; uint16_t ipc_port = 7077;
connection->async_connect (ipc_address, ipc_port, [connection](nano::error err) { connection->async_connect (ipc_address, ipc_port, [connection] (nano::error err) {
if (!err) if (!err)
{ {
nanoapi::TopicConfirmationT conf; nanoapi::TopicConfirmationT conf;
connection->async_write (nano::ipc::shared_buffer_from (conf), [connection](nano::error err, size_t size) { connection->async_write (nano::ipc::shared_buffer_from (conf), [connection] (nano::error err, size_t size) {
if (!err) if (!err)
{ {
std::cout << "Awaiting confirmations..." << std::endl; std::cout << "Awaiting confirmations..." << std::endl;

18
nano/lib/asio.cpp
View file

@ -1,31 +1,31 @@
#include <nano/lib/asio.hpp> #include <nano/lib/asio.hpp>
nano::shared_const_buffer::shared_const_buffer (const std::vector<uint8_t> & data) : nano::shared_const_buffer::shared_const_buffer (const std::vector<uint8_t> & data) :
m_data (std::make_shared<std::vector<uint8_t>> (data)), m_data (std::make_shared<std::vector<uint8_t>> (data)),
m_buffer (boost::asio::buffer (*m_data)) m_buffer (boost::asio::buffer (*m_data))
{ {
} }
nano::shared_const_buffer::shared_const_buffer (std::vector<uint8_t> && data) : nano::shared_const_buffer::shared_const_buffer (std::vector<uint8_t> && data) :
m_data (std::make_shared<std::vector<uint8_t>> (std::move (data))), m_data (std::make_shared<std::vector<uint8_t>> (std::move (data))),
m_buffer (boost::asio::buffer (*m_data)) m_buffer (boost::asio::buffer (*m_data))
{ {
} }
nano::shared_const_buffer::shared_const_buffer (uint8_t data) : nano::shared_const_buffer::shared_const_buffer (uint8_t data) :
shared_const_buffer (std::vector<uint8_t>{ data }) shared_const_buffer (std::vector<uint8_t>{ data })
{ {
} }
nano::shared_const_buffer::shared_const_buffer (std::string const & data) : nano::shared_const_buffer::shared_const_buffer (std::string const & data) :
m_data (std::make_shared<std::vector<uint8_t>> (data.begin (), data.end ())), m_data (std::make_shared<std::vector<uint8_t>> (data.begin (), data.end ())),
m_buffer (boost::asio::buffer (*m_data)) m_buffer (boost::asio::buffer (*m_data))
{ {
} }
nano::shared_const_buffer::shared_const_buffer (std::shared_ptr<std::vector<uint8_t>> const & data) : nano::shared_const_buffer::shared_const_buffer (std::shared_ptr<std::vector<uint8_t>> const & data) :
m_data (data), m_data (data),
m_buffer (boost::asio::buffer (*m_data)) m_buffer (boost::asio::buffer (*m_data))
{ {
} }

4
nano/lib/asio.hpp
View file

@ -29,7 +29,7 @@ private:
static_assert (boost::asio::is_const_buffer_sequence<shared_const_buffer>::value, "Not ConstBufferSequence compliant"); static_assert (boost::asio::is_const_buffer_sequence<shared_const_buffer>::value, "Not ConstBufferSequence compliant");
template <typename AsyncWriteStream, typename WriteHandler> template <typename AsyncWriteStream, typename WriteHandler>
BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void(boost::system::error_code, std::size_t)) BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void (boost::system::error_code, std::size_t))
async_write (AsyncWriteStream & s, nano::shared_const_buffer const & buffer, WriteHandler && handler) async_write (AsyncWriteStream & s, nano::shared_const_buffer const & buffer, WriteHandler && handler)
{ {
return boost::asio::async_write (s, buffer, std::move (handler)); return boost::asio::async_write (s, buffer, std::move (handler));
@ -41,7 +41,7 @@ async_write (AsyncWriteStream & s, nano::shared_const_buffer const & buffer, Wri
* @warning The buffers must be captured in the handler to ensure their lifetimes are properly extended. * @warning The buffers must be captured in the handler to ensure their lifetimes are properly extended.
*/ */
template <typename AsyncWriteStream, typename BufferType, typename WriteHandler> template <typename AsyncWriteStream, typename BufferType, typename WriteHandler>
BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void(boost::system::error_code, std::size_t)) BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void (boost::system::error_code, std::size_t))
unsafe_async_write (AsyncWriteStream & s, BufferType && buffer, WriteHandler && handler) unsafe_async_write (AsyncWriteStream & s, BufferType && buffer, WriteHandler && handler)
{ {
return boost::asio::async_write (s, buffer, std::move (handler)); return boost::asio::async_write (s, buffer, std::move (handler));

114
nano/lib/blocks.cpp
View file

@ -221,9 +221,9 @@ void nano::send_block::block_work_set (uint64_t work_a)
} }
nano::send_hashables::send_hashables (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a) : nano::send_hashables::send_hashables (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a) :
previous (previous_a), previous (previous_a),
destination (destination_a), destination (destination_a),
balance (balance_a) balance (balance_a)
{ {
} }
@ -364,14 +364,14 @@ bool nano::send_block::deserialize_json (boost::property_tree::ptree const & tre
} }
nano::send_block::send_block (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : nano::send_block::send_block (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, destination_a, balance_a), hashables (previous_a, destination_a, balance_a),
signature (nano::sign_message (prv_a, pub_a, hash ())), signature (nano::sign_message (prv_a, pub_a, hash ())),
work (work_a) work (work_a)
{ {
} }
nano::send_block::send_block (bool & error_a, nano::stream & stream_a) : nano::send_block::send_block (bool & error_a, nano::stream & stream_a) :
hashables (error_a, stream_a) hashables (error_a, stream_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -388,7 +388,7 @@ hashables (error_a, stream_a)
} }
nano::send_block::send_block (bool & error_a, boost::property_tree::ptree const & tree_a) : nano::send_block::send_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
hashables (error_a, tree_a) hashables (error_a, tree_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -474,9 +474,9 @@ void nano::send_block::signature_set (nano::signature const & signature_a)
} }
nano::open_hashables::open_hashables (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a) : nano::open_hashables::open_hashables (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a) :
source (source_a), source (source_a),
representative (representative_a), representative (representative_a),
account (account_a) account (account_a)
{ {
} }
@ -525,22 +525,22 @@ void nano::open_hashables::hash (blake2b_state & hash_a) const
} }
nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
hashables (source_a, representative_a, account_a), hashables (source_a, representative_a, account_a),
signature (nano::sign_message (prv_a, pub_a, hash ())), signature (nano::sign_message (prv_a, pub_a, hash ())),
work (work_a) work (work_a)
{ {
debug_assert (!representative_a.is_zero ()); debug_assert (!representative_a.is_zero ());
} }
nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, std::nullptr_t) : nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, std::nullptr_t) :
hashables (source_a, representative_a, account_a), hashables (source_a, representative_a, account_a),
work (0) work (0)
{ {
signature.clear (); signature.clear ();
} }
nano::open_block::open_block (bool & error_a, nano::stream & stream_a) : nano::open_block::open_block (bool & error_a, nano::stream & stream_a) :
hashables (error_a, stream_a) hashables (error_a, stream_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -557,7 +557,7 @@ hashables (error_a, stream_a)
} }
nano::open_block::open_block (bool & error_a, boost::property_tree::ptree const & tree_a) : nano::open_block::open_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
hashables (error_a, tree_a) hashables (error_a, tree_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -745,8 +745,8 @@ void nano::open_block::signature_set (nano::signature const & signature_a)
} }
nano::change_hashables::change_hashables (nano::block_hash const & previous_a, nano::account const & representative_a) : nano::change_hashables::change_hashables (nano::block_hash const & previous_a, nano::account const & representative_a) :
previous (previous_a), previous (previous_a),
representative (representative_a) representative (representative_a)
{ {
} }
@ -788,14 +788,14 @@ void nano::change_hashables::hash (blake2b_state & hash_a) const
} }
nano::change_block::change_block (nano::block_hash const & previous_a, nano::account const & representative_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : nano::change_block::change_block (nano::block_hash const & previous_a, nano::account const & representative_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, representative_a), hashables (previous_a, representative_a),
signature (nano::sign_message (prv_a, pub_a, hash ())), signature (nano::sign_message (prv_a, pub_a, hash ())),
work (work_a) work (work_a)
{ {
} }
nano::change_block::change_block (bool & error_a, nano::stream & stream_a) : nano::change_block::change_block (bool & error_a, nano::stream & stream_a) :
hashables (error_a, stream_a) hashables (error_a, stream_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -812,7 +812,7 @@ hashables (error_a, stream_a)
} }
nano::change_block::change_block (bool & error_a, boost::property_tree::ptree const & tree_a) : nano::change_block::change_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
hashables (error_a, tree_a) hashables (error_a, tree_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -994,11 +994,11 @@ void nano::change_block::signature_set (nano::signature const & signature_a)
} }
nano::state_hashables::state_hashables (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a) : nano::state_hashables::state_hashables (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a) :
account (account_a), account (account_a),
previous (previous_a), previous (previous_a),
representative (representative_a), representative (representative_a),
balance (balance_a), balance (balance_a),
link (link_a) link (link_a)
{ {
} }
@ -1061,14 +1061,14 @@ void nano::state_hashables::hash (blake2b_state & hash_a) const
} }
nano::state_block::state_block (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : nano::state_block::state_block (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
hashables (account_a, previous_a, representative_a, balance_a, link_a), hashables (account_a, previous_a, representative_a, balance_a, link_a),
signature (nano::sign_message (prv_a, pub_a, hash ())), signature (nano::sign_message (prv_a, pub_a, hash ())),
work (work_a) work (work_a)
{ {
} }
nano::state_block::state_block (bool & error_a, nano::stream & stream_a) : nano::state_block::state_block (bool & error_a, nano::stream & stream_a) :
hashables (error_a, stream_a) hashables (error_a, stream_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1086,7 +1086,7 @@ hashables (error_a, stream_a)
} }
nano::state_block::state_block (bool & error_a, boost::property_tree::ptree const & tree_a) : nano::state_block::state_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
hashables (error_a, tree_a) hashables (error_a, tree_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1506,14 +1506,14 @@ bool nano::receive_block::deserialize_json (boost::property_tree::ptree const &
} }
nano::receive_block::receive_block (nano::block_hash const & previous_a, nano::block_hash const & source_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : nano::receive_block::receive_block (nano::block_hash const & previous_a, nano::block_hash const & source_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, source_a), hashables (previous_a, source_a),
signature (nano::sign_message (prv_a, pub_a, hash ())), signature (nano::sign_message (prv_a, pub_a, hash ())),
work (work_a) work (work_a)
{ {
} }
nano::receive_block::receive_block (bool & error_a, nano::stream & stream_a) : nano::receive_block::receive_block (bool & error_a, nano::stream & stream_a) :
hashables (error_a, stream_a) hashables (error_a, stream_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1530,7 +1530,7 @@ hashables (error_a, stream_a)
} }
nano::receive_block::receive_block (bool & error_a, boost::property_tree::ptree const & tree_a) : nano::receive_block::receive_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
hashables (error_a, tree_a) hashables (error_a, tree_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1620,8 +1620,8 @@ nano::block_type nano::receive_block::type () const
} }
nano::receive_hashables::receive_hashables (nano::block_hash const & previous_a, nano::block_hash const & source_a) : nano::receive_hashables::receive_hashables (nano::block_hash const & previous_a, nano::block_hash const & source_a) :
previous (previous_a), previous (previous_a),
source (source_a) source (source_a)
{ {
} }
@ -1663,7 +1663,7 @@ void nano::receive_hashables::hash (blake2b_state & hash_a) const
} }
nano::block_details::block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a) : nano::block_details::block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a) :
epoch (epoch_a), is_send (is_send_a), is_receive (is_receive_a), is_epoch (is_epoch_a) epoch (epoch_a), is_send (is_send_a), is_receive (is_receive_a), is_epoch (is_epoch_a)
{ {
} }
@ -1735,24 +1735,24 @@ std::string nano::state_subtype (nano::block_details const details_a)
} }
nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::block_details const & details_a, nano::epoch const source_epoch_a) : nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::block_details const & details_a, nano::epoch const source_epoch_a) :
successor (successor_a), successor (successor_a),
account (account_a), account (account_a),
balance (balance_a), balance (balance_a),
height (height_a), height (height_a),
timestamp (timestamp_a), timestamp (timestamp_a),
details (details_a), details (details_a),
source_epoch (source_epoch_a) source_epoch (source_epoch_a)
{ {
} }
nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::epoch const epoch_a, bool const is_send, bool const is_receive, bool const is_epoch, nano::epoch const source_epoch_a) : nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::epoch const epoch_a, bool const is_send, bool const is_receive, bool const is_epoch, nano::epoch const source_epoch_a) :
successor (successor_a), successor (successor_a),
account (account_a), account (account_a),
balance (balance_a), balance (balance_a),
height (height_a), height (height_a),
timestamp (timestamp_a), timestamp (timestamp_a),
details (epoch_a, is_send, is_receive, is_epoch), details (epoch_a, is_send, is_receive, is_epoch),
source_epoch (source_epoch_a) source_epoch (source_epoch_a)
{ {
} }

12
nano/lib/config.hpp
View file

@ -92,9 +92,9 @@ struct work_thresholds
uint64_t const entry; uint64_t const entry;
constexpr work_thresholds (uint64_t epoch_1_a, uint64_t epoch_2_a, uint64_t epoch_2_receive_a) : constexpr work_thresholds (uint64_t epoch_1_a, uint64_t epoch_2_a, uint64_t epoch_2_receive_a) :
epoch_1 (epoch_1_a), epoch_2 (epoch_2_a), epoch_2_receive (epoch_2_receive_a), epoch_1 (epoch_1_a), epoch_2 (epoch_2_a), epoch_2_receive (epoch_2_receive_a),
base (std::max ({ epoch_1, epoch_2, epoch_2_receive })), base (std::max ({ epoch_1, epoch_2, epoch_2_receive })),
entry (std::min ({ epoch_1, epoch_2, epoch_2_receive })) entry (std::min ({ epoch_1, epoch_2, epoch_2_receive }))
{ {
} }
work_thresholds () = delete; work_thresholds () = delete;
@ -108,13 +108,13 @@ class network_constants
{ {
public: public:
network_constants () : network_constants () :
network_constants (network_constants::active_network) network_constants (network_constants::active_network)
{ {
} }
network_constants (nano_networks network_a) : network_constants (nano_networks network_a) :
current_network (network_a), current_network (network_a),
publish_thresholds (is_live_network () ? publish_full : is_beta_network () ? publish_beta : is_test_network () ? publish_test : publish_dev) publish_thresholds (is_live_network () ? publish_full : is_beta_network () ? publish_beta : is_test_network () ? publish_test : publish_dev)
{ {
// A representative is classified as principal based on its weight and this factor // A representative is classified as principal based on its weight and this factor
principal_weight_factor = 1000; // 0.1% principal_weight_factor = 1000; // 0.1%

4
nano/lib/configbase.hpp
View file

@ -14,7 +14,7 @@ namespace nano
/** Type trait to determine if T is compatible with boost's lexical_cast */ /** Type trait to determine if T is compatible with boost's lexical_cast */
template <class T> template <class T>
struct is_lexical_castable : std::integral_constant<bool, struct is_lexical_castable : std::integral_constant<bool,
(std::is_default_constructible<T>::value && (boost::has_right_shift<std::basic_istream<wchar_t>, T>::value || boost::has_right_shift<std::basic_istream<char>, T>::value))> (std::is_default_constructible<T>::value && (boost::has_right_shift<std::basic_istream<wchar_t>, T>::value || boost::has_right_shift<std::basic_istream<char>, T>::value))>
{ {
}; };
@ -42,7 +42,7 @@ class configbase : public nano::error_aware<>
public: public:
configbase () = default; configbase () = default;
configbase (std::shared_ptr<nano::error> const & error_a) : configbase (std::shared_ptr<nano::error> const & error_a) :
error (error_a) error (error_a)
{ {
} }

4
nano/lib/epoch.cpp
View file

@ -8,7 +8,7 @@ nano::link const & nano::epochs::link (nano::epoch epoch_a) const
bool nano::epochs::is_epoch_link (nano::link const & link_a) const bool nano::epochs::is_epoch_link (nano::link const & link_a) const
{ {
return std::any_of (epochs_m.begin (), epochs_m.end (), [&link_a](auto const & item_a) { return item_a.second.link == link_a; }); return std::any_of (epochs_m.begin (), epochs_m.end (), [&link_a] (auto const & item_a) { return item_a.second.link == link_a; });
} }
nano::public_key const & nano::epochs::signer (nano::epoch epoch_a) const nano::public_key const & nano::epochs::signer (nano::epoch epoch_a) const
@ -18,7 +18,7 @@ nano::public_key const & nano::epochs::signer (nano::epoch epoch_a) const
nano::epoch nano::epochs::epoch (nano::link const & link_a) const nano::epoch nano::epochs::epoch (nano::link const & link_a) const
{ {
auto existing (std::find_if (epochs_m.begin (), epochs_m.end (), [&link_a](auto const & item_a) { return item_a.second.link == link_a; })); auto existing (std::find_if (epochs_m.begin (), epochs_m.end (), [&link_a] (auto const & item_a) { return item_a.second.link == link_a; }));
debug_assert (existing != epochs_m.end ()); debug_assert (existing != epochs_m.end ());
return existing->first; return existing->first;
} }

4
nano/lib/errors.hpp
View file

@ -209,7 +209,7 @@ namespace std
{ {
template <> template <>
struct is_error_code_enum<boost::system::errc::errc_t> struct is_error_code_enum<boost::system::errc::errc_t>
: public std::true_type : public std::true_type
{ {
}; };
@ -262,7 +262,7 @@ public:
{ {
// Convert variadic arguments to std::error_code // Convert variadic arguments to std::error_code
auto codes = { std::error_code (err)... }; auto codes = { std::error_code (err)... };
if (std::any_of (codes.begin (), codes.end (), [this, &codes](auto & code_a) { return code == code_a; })) if (std::any_of (codes.begin (), codes.end (), [this, &codes] (auto & code_a) { return code == code_a; }))
{ {
code.clear (); code.clear ();
} }

6
nano/lib/ipc.cpp
View file

@ -2,7 +2,7 @@
#include <nano/lib/utility.hpp> #include <nano/lib/utility.hpp>
nano::ipc::socket_base::socket_base (boost::asio::io_context & io_ctx_a) : nano::ipc::socket_base::socket_base (boost::asio::io_context & io_ctx_a) :
io_timer (io_ctx_a) io_timer (io_ctx_a)
{ {
} }
@ -11,7 +11,7 @@ void nano::ipc::socket_base::timer_start (std::chrono::seconds timeout_a)
if (timeout_a < std::chrono::seconds::max ()) if (timeout_a < std::chrono::seconds::max ())
{ {
io_timer.expires_from_now (boost::posix_time::seconds (static_cast<long> (timeout_a.count ()))); io_timer.expires_from_now (boost::posix_time::seconds (static_cast<long> (timeout_a.count ())));
io_timer.async_wait ([this](const boost::system::error_code & ec) { io_timer.async_wait ([this] (const boost::system::error_code & ec) {
if (!ec) if (!ec)
{ {
this->timer_expired (); this->timer_expired ();
@ -33,7 +33,7 @@ void nano::ipc::socket_base::timer_cancel ()
} }
nano::ipc::dsock_file_remover::dsock_file_remover (std::string const & file_a) : nano::ipc::dsock_file_remover::dsock_file_remover (std::string const & file_a) :
filename (file_a) filename (file_a)
{ {
std::remove (filename.c_str ()); std::remove (filename.c_str ());
} }

72
nano/lib/ipc_client.cpp
View file

@ -19,8 +19,8 @@ namespace
class channel class channel
{ {
public: public:
virtual void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0; virtual void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0; virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
/** /**
* Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may * Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may
@ -30,7 +30,7 @@ public:
* @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense. * @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense.
* @param callback_a If called without errors, the payload buffer is successfully populated * @param callback_a If called without errors, the payload buffer is successfully populated
*/ */
virtual void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0; virtual void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
}; };
/* Boost v1.70 introduced breaking changes; the conditional compilation allows 1.6x to be supported as well. */ /* Boost v1.70 introduced breaking changes; the conditional compilation allows 1.6x to be supported as well. */
@ -46,15 +46,15 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
{ {
public: public:
socket_client (boost::asio::io_context & io_ctx_a, ENDPOINT_TYPE endpoint_a) : socket_client (boost::asio::io_context & io_ctx_a, ENDPOINT_TYPE endpoint_a) :
socket_base (io_ctx_a), endpoint (endpoint_a), socket (io_ctx_a), resolver (io_ctx_a), strand (io_ctx_a.get_executor ()) socket_base (io_ctx_a), endpoint (endpoint_a), socket (io_ctx_a), resolver (io_ctx_a), strand (io_ctx_a.get_executor ())
{ {
} }
void async_resolve (std::string const & host_a, uint16_t port_a, std::function<void(boost::system::error_code const &, boost::asio::ip::tcp::endpoint)> callback_a) void async_resolve (std::string const & host_a, uint16_t port_a, std::function<void (boost::system::error_code const &, boost::asio::ip::tcp::endpoint)> callback_a)
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
this_l->timer_start (io_timeout); this_l->timer_start (io_timeout);
resolver.async_resolve (boost::asio::ip::tcp::resolver::query (host_a, std::to_string (port_a)), [this_l, callback_a](boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator_a) { resolver.async_resolve (boost::asio::ip::tcp::resolver::query (host_a, std::to_string (port_a)), [this_l, callback_a] (boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator_a) {
this_l->timer_cancel (); this_l->timer_cancel ();
boost::asio::ip::tcp::resolver::iterator end; boost::asio::ip::tcp::resolver::iterator end;
if (!ec && endpoint_iterator_a != end) if (!ec && endpoint_iterator_a != end)
@ -69,31 +69,31 @@ public:
}); });
} }
void async_connect (std::function<void(boost::system::error_code const &)> callback_a) void async_connect (std::function<void (boost::system::error_code const &)> callback_a)
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
this_l->timer_start (io_timeout); this_l->timer_start (io_timeout);
socket.async_connect (endpoint, boost::asio::bind_executor (strand, [this_l, callback_a](boost::system::error_code const & ec) { socket.async_connect (endpoint, boost::asio::bind_executor (strand, [this_l, callback_a] (boost::system::error_code const & ec) {
this_l->timer_cancel (); this_l->timer_cancel ();
callback_a (ec); callback_a (ec);
})); }));
} }
void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
this_l->timer_start (io_timeout); this_l->timer_start (io_timeout);
buffer_a->resize (size_a); buffer_a->resize (size_a);
boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, [this_l, buffer_a, callback_a](boost::system::error_code const & ec, size_t size_a) { boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, [this_l, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) {
this_l->timer_cancel (); this_l->timer_cancel ();
callback_a (ec, size_a); callback_a (ec, size_a);
})); }));
} }
void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l]() { boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l] () {
bool write_in_progress = !this_l->send_queue.empty (); bool write_in_progress = !this_l->send_queue.empty ();
auto queue_size = this_l->send_queue.size (); auto queue_size = this_l->send_queue.size ();
if (queue_size < this_l->queue_size_max) if (queue_size < this_l->queue_size_max)
@ -114,7 +114,7 @@ public:
this_l->timer_start (io_timeout); this_l->timer_start (io_timeout);
nano::async_write (socket, msg.buffer, nano::async_write (socket, msg.buffer,
boost::asio::bind_executor (strand, boost::asio::bind_executor (strand,
[msg, this_l](boost::system::error_code ec, std::size_t size_a) { [msg, this_l] (boost::system::error_code ec, std::size_t size_a) {
this_l->timer_cancel (); this_l->timer_cancel ();
if (msg.callback) if (msg.callback)
@ -130,13 +130,13 @@ public:
})); }));
} }
void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
this_l->timer_start (timeout_a); this_l->timer_start (timeout_a);
buffer_a->resize (4); buffer_a->resize (4);
// Read 32 bit big-endian length // Read 32 bit big-endian length
boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), 4), boost::asio::bind_executor (this_l->strand, [this_l, timeout_a, buffer_a, callback_a](boost::system::error_code const & ec, size_t size_a) { boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), 4), boost::asio::bind_executor (this_l->strand, [this_l, timeout_a, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) {
this_l->timer_cancel (); this_l->timer_cancel ();
if (!ec) if (!ec)
{ {
@ -144,7 +144,7 @@ public:
buffer_a->resize (payload_size_l); buffer_a->resize (payload_size_l);
// Read payload // Read payload
this_l->timer_start (timeout_a); this_l->timer_start (timeout_a);
this_l->async_read (buffer_a, payload_size_l, [this_l, buffer_a, callback_a](boost::system::error_code const & ec_a, size_t size_a) { this_l->async_read (buffer_a, payload_size_l, [this_l, buffer_a, callback_a] (boost::system::error_code const & ec_a, size_t size_a) {
this_l->timer_cancel (); this_l->timer_cancel ();
callback_a (ec_a, size_a); callback_a (ec_a, size_a);
}); });
@ -160,7 +160,7 @@ public:
void close () override void close () override
{ {
auto this_l (this->shared_from_this ()); auto this_l (this->shared_from_this ());
boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l]() { boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l] () {
this_l->socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both); this_l->socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both);
this_l->socket.close (); this_l->socket.close ();
})); }));
@ -171,12 +171,12 @@ private:
class queue_item class queue_item
{ {
public: public:
queue_item (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) : queue_item (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) :
buffer (buffer_a), callback (callback_a) buffer (buffer_a), callback (callback_a)
{ {
} }
nano::shared_const_buffer buffer; nano::shared_const_buffer buffer;
std::function<void(boost::system::error_code const &, size_t)> callback; std::function<void (boost::system::error_code const &, size_t)> callback;
}; };
size_t const queue_size_max = 64 * 1024; size_t const queue_size_max = 64 * 1024;
/** The send queue is protected by always being accessed through the strand */ /** The send queue is protected by always being accessed through the strand */
@ -197,18 +197,18 @@ class client_impl : public nano::ipc::ipc_client_impl
{ {
public: public:
explicit client_impl (boost::asio::io_context & io_ctx_a) : explicit client_impl (boost::asio::io_context & io_ctx_a) :
io_ctx (io_ctx_a) io_ctx (io_ctx_a)
{ {
} }
void connect (std::string const & host_a, uint16_t port_a, std::function<void(nano::error)> callback_a) void connect (std::string const & host_a, uint16_t port_a, std::function<void (nano::error)> callback_a)
{ {
tcp_client = std::make_shared<socket_client<socket_type, boost::asio::ip::tcp::endpoint>> (io_ctx, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v6 (), port_a)); tcp_client = std::make_shared<socket_client<socket_type, boost::asio::ip::tcp::endpoint>> (io_ctx, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v6 (), port_a));
tcp_client->async_resolve (host_a, port_a, [this, callback_a](boost::system::error_code const & ec_resolve_a, boost::asio::ip::tcp::endpoint endpoint_a) { tcp_client->async_resolve (host_a, port_a, [this, callback_a] (boost::system::error_code const & ec_resolve_a, boost::asio::ip::tcp::endpoint endpoint_a) {
if (!ec_resolve_a) if (!ec_resolve_a)
{ {
this->tcp_client->async_connect ([callback_a](const boost::system::error_code & ec_connect_a) { this->tcp_client->async_connect ([callback_a] (const boost::system::error_code & ec_connect_a) {
callback_a (nano::error (ec_connect_a)); callback_a (nano::error (ec_connect_a));
}); });
} }
@ -249,7 +249,7 @@ private:
} }
nano::ipc::ipc_client::ipc_client (boost::asio::io_context & io_ctx_a) : nano::ipc::ipc_client::ipc_client (boost::asio::io_context & io_ctx_a) :
io_ctx (io_ctx_a) io_ctx (io_ctx_a)
{ {
} }
@ -259,7 +259,7 @@ nano::error nano::ipc::ipc_client::connect (std::string const & path_a)
return boost::polymorphic_downcast<client_impl *> (impl.get ())->connect (path_a); return boost::polymorphic_downcast<client_impl *> (impl.get ())->connect (path_a);
} }
void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t port_a, std::function<void(nano::error)> callback_a) void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t port_a, std::function<void (nano::error)> callback_a)
{ {
impl = std::make_unique<client_impl> (io_ctx); impl = std::make_unique<client_impl> (io_ctx);
auto client (boost::polymorphic_downcast<client_impl *> (impl.get ())); auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
@ -269,33 +269,33 @@ void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t
nano::error nano::ipc::ipc_client::connect (std::string const & host, uint16_t port) nano::error nano::ipc::ipc_client::connect (std::string const & host, uint16_t port)
{ {
std::promise<nano::error> result_l; std::promise<nano::error> result_l;
async_connect (host, port, [&result_l](nano::error err_a) { async_connect (host, port, [&result_l] (nano::error err_a) {
result_l.set_value (err_a); result_l.set_value (err_a);
}); });
return result_l.get_future ().get (); return result_l.get_future ().get ();
} }
void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffer_a, std::function<void(nano::error, size_t)> callback_a) void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (nano::error, size_t)> callback_a)
{ {
auto client (boost::polymorphic_downcast<client_impl *> (impl.get ())); auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
client->get_channel ().async_write (buffer_a, [callback_a](const boost::system::error_code & ec_a, size_t bytes_written_a) { client->get_channel ().async_write (buffer_a, [callback_a] (const boost::system::error_code & ec_a, size_t bytes_written_a) {
callback_a (nano::error (ec_a), bytes_written_a); callback_a (nano::error (ec_a), bytes_written_a);
}); });
} }
void nano::ipc::ipc_client::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(nano::error, size_t)> callback_a) void nano::ipc::ipc_client::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (nano::error, size_t)> callback_a)
{ {
auto client (boost::polymorphic_downcast<client_impl *> (impl.get ())); auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a](const boost::system::error_code & ec_a, size_t bytes_read_a) { client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) {
callback_a (nano::error (ec_a), bytes_read_a); callback_a (nano::error (ec_a), bytes_read_a);
}); });
} }
/** Read a length-prefixed message asynchronously. Received length must be a big endian 32-bit unsigned integer. */ /** Read a length-prefixed message asynchronously. Received length must be a big endian 32-bit unsigned integer. */
void nano::ipc::ipc_client::async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(nano::error, size_t)> callback_a) void nano::ipc::ipc_client::async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (nano::error, size_t)> callback_a)
{ {
auto client (boost::polymorphic_downcast<client_impl *> (impl.get ())); auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a](const boost::system::error_code & ec_a, size_t bytes_read_a) { client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) {
callback_a (nano::error (ec_a), bytes_read_a); callback_a (nano::error (ec_a), bytes_read_a);
}); });
} }
@ -342,12 +342,12 @@ std::string nano::ipc::request (nano::ipc::payload_encoding encoding_a, nano::ip
auto res (std::make_shared<std::vector<uint8_t>> ()); auto res (std::make_shared<std::vector<uint8_t>> ());
std::promise<std::string> result_l; std::promise<std::string> result_l;
ipc_client.async_write (req, [&ipc_client, &res, &result_l](nano::error err_a, size_t size_a) { ipc_client.async_write (req, [&ipc_client, &res, &result_l] (nano::error err_a, size_t size_a) {
// Read length // Read length
ipc_client.async_read (res, sizeof (uint32_t), [&ipc_client, &res, &result_l](nano::error err_read_a, size_t size_read_a) { ipc_client.async_read (res, sizeof (uint32_t), [&ipc_client, &res, &result_l] (nano::error err_read_a, size_t size_read_a) {
uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ())); uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ()));
// Read json payload // Read json payload
ipc_client.async_read (res, payload_size_l, [&res, &result_l](nano::error err_read_a, size_t size_read_a) { ipc_client.async_read (res, payload_size_l, [&res, &result_l] (nano::error err_read_a, size_t size_read_a) {
result_l.set_value (std::string (res->begin (), res->end ())); result_l.set_value (std::string (res->begin (), res->end ()));
}); });
}); });

8
nano/lib/ipc_client.hpp
View file

@ -38,13 +38,13 @@ namespace ipc
nano::error connect (std::string const & host, uint16_t port); nano::error connect (std::string const & host, uint16_t port);
/** Connect to a tcp socket asynchronously */ /** Connect to a tcp socket asynchronously */
void async_connect (std::string const & host, uint16_t port, std::function<void(nano::error)> callback); void async_connect (std::string const & host, uint16_t port, std::function<void (nano::error)> callback);
/** Write buffer asynchronously */ /** Write buffer asynchronously */
void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(nano::error, size_t)> callback_a); void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (nano::error, size_t)> callback_a);
/** Read \p size_a bytes asynchronously */ /** Read \p size_a bytes asynchronously */
void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(nano::error, size_t)> callback_a); void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (nano::error, size_t)> callback_a);
/** /**
* Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may * Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may
@ -54,7 +54,7 @@ namespace ipc
* @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense. * @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense.
* @param callback_a If called without errors, the payload buffer is successfully populated * @param callback_a If called without errors, the payload buffer is successfully populated
*/ */
void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(nano::error, size_t)> callback_a); void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (nano::error, size_t)> callback_a);
private: private:
boost::asio::io_context & io_ctx; boost::asio::io_context & io_ctx;

2
nano/lib/json_error_response.hpp
View file

@ -5,7 +5,7 @@
namespace nano namespace nano
{ {
inline void json_error_response (std::function<void(std::string const &)> response_a, std::string const & message_a) inline void json_error_response (std::function<void (std::string const &)> response_a, std::string const & message_a)
{ {
boost::property_tree::ptree response_l; boost::property_tree::ptree response_l;
response_l.put ("error", message_a); response_l.put ("error", message_a);

6
nano/lib/jsonconfig.cpp
View file

@ -7,13 +7,13 @@
#include <cstddef> #include <cstddef>
nano::jsonconfig::jsonconfig () : nano::jsonconfig::jsonconfig () :
tree (tree_default) tree (tree_default)
{ {
error = std::make_shared<nano::error> (); error = std::make_shared<nano::error> ();
} }
nano::jsonconfig::jsonconfig (boost::property_tree::ptree & tree_a, std::shared_ptr<nano::error> const & error_a) : nano::jsonconfig::jsonconfig (boost::property_tree::ptree & tree_a, std::shared_ptr<nano::error> const & error_a) :
nano::configbase (error_a), tree (tree_a) nano::configbase (error_a), tree (tree_a)
{ {
if (!error) if (!error)
{ {
@ -192,7 +192,7 @@ nano::jsonconfig & nano::jsonconfig::get_config (bool optional, std::string key,
nano::jsonconfig & nano::jsonconfig::get_config (bool optional, std::string key, bool & target, bool default_value) nano::jsonconfig & nano::jsonconfig::get_config (bool optional, std::string key, bool & target, bool default_value)
{ {
auto bool_conv = [this, &target, &key, optional](std::string val) { auto bool_conv = [this, &target, &key, optional] (std::string val) {
if (val == "true") if (val == "true")
{ {
target = true; target = true;

2
nano/lib/jsonconfig.hpp
View file

@ -101,7 +101,7 @@ public:
/** Iterate array entries */ /** Iterate array entries */
template <typename T> template <typename T>
jsonconfig & array_entries (std::function<void(T)> callback) jsonconfig & array_entries (std::function<void (T)> callback)
{ {
for (auto & entry : tree) for (auto & entry : tree)
{ {

8
nano/lib/locks.cpp
View file

@ -19,7 +19,7 @@ void output (const char * str, std::chrono::milliseconds time, Mutex & mutex)
// Guard standard out to keep the output from being interleaved // Guard standard out to keep the output from being interleaved
std::lock_guard guard (cout_mutex); std::lock_guard guard (cout_mutex);
std::cout << (boost::format ("%1% Mutex %2% %3% for %4%ms\n%5%") % std::addressof (mutex) % mutex.get_name () % str % time.count () % stacktrace).str () std::cout << (boost::format ("%1% Mutex %2% %3% for %4%ms\n%5%") % std::addressof (mutex) % mutex.get_name () % str % time.count () % stacktrace).str ()
<< std::endl; << std::endl;
} }
template <typename Mutex> template <typename Mutex>
@ -59,7 +59,7 @@ void output_if_blocked_long_enough (nano::timer<std::chrono::milliseconds> & tim
#endif #endif
lock_guard<nano::mutex>::lock_guard (nano::mutex & mutex) : lock_guard<nano::mutex>::lock_guard (nano::mutex & mutex) :
mut (mutex) mut (mutex)
{ {
timer.start (); timer.start ();
@ -77,14 +77,14 @@ lock_guard<nano::mutex>::~lock_guard () noexcept
template <typename Mutex, typename U> template <typename Mutex, typename U>
unique_lock<Mutex, U>::unique_lock (Mutex & mutex) : unique_lock<Mutex, U>::unique_lock (Mutex & mutex) :
mut (std::addressof (mutex)) mut (std::addressof (mutex))
{ {
lock_impl (); lock_impl ();
} }
template <typename Mutex, typename U> template <typename Mutex, typename U>
unique_lock<Mutex, U>::unique_lock (Mutex & mutex, std::defer_lock_t) noexcept : unique_lock<Mutex, U>::unique_lock (Mutex & mutex, std::defer_lock_t) noexcept :
mut (std::addressof (mutex)) mut (std::addressof (mutex))
{ {
} }

10
nano/lib/locks.hpp
View file

@ -47,8 +47,8 @@ public:
mutex () = default; mutex () = default;
mutex (const char * name_a) mutex (const char * name_a)
#if USING_NANO_TIMED_LOCKS #if USING_NANO_TIMED_LOCKS
: :
name (name_a) name (name_a)
#endif #endif
{ {
#if USING_NANO_TIMED_LOCKS #if USING_NANO_TIMED_LOCKS
@ -120,7 +120,7 @@ class lock_guard final
{ {
public: public:
explicit lock_guard (Mutex & mutex_a) : explicit lock_guard (Mutex & mutex_a) :
guard (mutex_a) guard (mutex_a)
{ {
} }
@ -266,14 +266,14 @@ public:
template <typename... Args> template <typename... Args>
locked (Args &&... args) : locked (Args &&... args) :
obj (std::forward<Args> (args)...) obj (std::forward<Args> (args)...)
{ {
} }
struct scoped_lock final struct scoped_lock final
{ {
scoped_lock (locked * owner_a) : scoped_lock (locked * owner_a) :
owner (owner_a) owner (owner_a)
{ {
owner->mutex.lock (); owner->mutex.lock ();
} }

2
nano/lib/logger_mt.hpp
View file

@ -75,7 +75,7 @@ public:
* @param min_log_delta_a The minimum time between successive output * @param min_log_delta_a The minimum time between successive output
*/ */
explicit logger_mt (std::chrono::milliseconds const & min_log_delta_a) : explicit logger_mt (std::chrono::milliseconds const & min_log_delta_a) :
min_log_delta (min_log_delta_a) min_log_delta (min_log_delta_a)
{ {
} }

4
nano/lib/memory.cpp
View file

@ -23,8 +23,8 @@ void nano::set_use_memory_pools (bool use_memory_pools_a)
#endif #endif
} }
nano::cleanup_guard::cleanup_guard (std::vector<std::function<void()>> const & cleanup_funcs_a) : nano::cleanup_guard::cleanup_guard (std::vector<std::function<void ()>> const & cleanup_funcs_a) :
cleanup_funcs (cleanup_funcs_a) cleanup_funcs (cleanup_funcs_a)
{ {
} }

4
nano/lib/memory.hpp
View file

@ -41,11 +41,11 @@ bool purge_shared_ptr_singleton_pool_memory ()
class cleanup_guard final class cleanup_guard final
{ {
public: public:
cleanup_guard (std::vector<std::function<void()>> const & cleanup_funcs_a); cleanup_guard (std::vector<std::function<void ()>> const & cleanup_funcs_a);
~cleanup_guard (); ~cleanup_guard ();
private: private:
std::vector<std::function<void()>> cleanup_funcs; std::vector<std::function<void ()>> cleanup_funcs;
}; };
template <typename T, typename... Args> template <typename T, typename... Args>

2
nano/lib/numbers.cpp
View file

@ -782,7 +782,7 @@ std::string nano::uint128_union::to_string_dec () const
} }
nano::hash_or_account::hash_or_account (uint64_t value_a) : nano::hash_or_account::hash_or_account (uint64_t value_a) :
raw (value_a) raw (value_a)
{ {
} }

2
nano/lib/optional_ptr.hpp
View file

@ -24,7 +24,7 @@ public:
optional_ptr () = default; optional_ptr () = default;
optional_ptr (T const & value) : optional_ptr (T const & value) :
ptr (new T{ value }) ptr (new T{ value })
{ {
} }

4
nano/lib/rpc_handler_interface.hpp
View file

@ -57,9 +57,9 @@ class rpc_handler_interface
public: public:
virtual ~rpc_handler_interface () = default; virtual ~rpc_handler_interface () = default;
/** Process RPC 1.0 request. */ /** Process RPC 1.0 request. */
virtual void process_request (std::string const & action, std::string const & body, std::function<void(std::string const &)> response) = 0; virtual void process_request (std::string const & action, std::string const & body, std::function<void (std::string const &)> response) = 0;
/** Process RPC 2.0 request. This is called via the IPC API */ /** Process RPC 2.0 request. This is called via the IPC API */
virtual void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body, std::function<void(std::shared_ptr<std::string> const &)> response) = 0; virtual void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body, std::function<void (std::shared_ptr<std::string> const &)> response) = 0;
virtual void stop () = 0; virtual void stop () = 0;
virtual void rpc_instance (nano::rpc & rpc) = 0; virtual void rpc_instance (nano::rpc & rpc) = 0;
}; };

14
nano/lib/rpcconfig.cpp
View file

@ -55,14 +55,14 @@ nano::error nano::rpc_secure_config::deserialize_toml (nano::tomlconfig & toml)
} }
nano::rpc_config::rpc_config () : nano::rpc_config::rpc_config () :
address (boost::asio::ip::address_v6::loopback ().to_string ()) address (boost::asio::ip::address_v6::loopback ().to_string ())
{ {
} }
nano::rpc_config::rpc_config (uint16_t port_a, bool enable_control_a) : nano::rpc_config::rpc_config (uint16_t port_a, bool enable_control_a) :
address (boost::asio::ip::address_v6::loopback ().to_string ()), address (boost::asio::ip::address_v6::loopback ().to_string ()),
port (port_a), port (port_a),
enable_control (enable_control_a) enable_control (enable_control_a)
{ {
} }
@ -184,7 +184,7 @@ nano::error nano::rpc_config::deserialize_toml (nano::tomlconfig & toml)
} }
nano::rpc_process_config::rpc_process_config () : nano::rpc_process_config::rpc_process_config () :
ipc_address (boost::asio::ip::address_v6::loopback ().to_string ()) ipc_address (boost::asio::ip::address_v6::loopback ().to_string ())
{ {
} }
@ -200,8 +200,8 @@ nano::error read_rpc_config_toml (boost::filesystem::path const & data_path_a, n
if (boost::filesystem::exists (toml_config_path)) if (boost::filesystem::exists (toml_config_path))
{ {
error = "Both json and toml rpc configuration files exists. " error = "Both json and toml rpc configuration files exists. "
"Either remove the config.json file and restart, or remove " "Either remove the config.json file and restart, or remove "
"the config-rpc.toml file to start migration on next launch."; "the config-rpc.toml file to start migration on next launch.";
} }
else else
{ {

4
nano/lib/stats.cpp
View file

@ -175,7 +175,7 @@ public:
std::string filename; std::string filename;
explicit file_writer (std::string const & filename) : explicit file_writer (std::string const & filename) :
filename (filename) filename (filename)
{ {
log.open (filename.c_str (), std::ofstream::out); log.open (filename.c_str (), std::ofstream::out);
} }
@ -283,7 +283,7 @@ std::vector<nano::stat_histogram::bin> nano::stat_histogram::get_bins () const
} }
nano::stat::stat (nano::stat_config config) : nano::stat::stat (nano::stat_config config) :
config (config) config (config)
{ {
} }

10
nano/lib/stats.hpp
View file

@ -98,7 +98,7 @@ public:
{ {
public: public:
bin (uint64_t start_inclusive_a, uint64_t end_exclusive_a) : bin (uint64_t start_inclusive_a, uint64_t end_exclusive_a) :
start_inclusive (start_inclusive_a), end_exclusive (end_exclusive_a) start_inclusive (start_inclusive_a), end_exclusive (end_exclusive_a)
{ {
} }
uint64_t start_inclusive; uint64_t start_inclusive;
@ -120,7 +120,7 @@ class stat_entry final
{ {
public: public:
stat_entry (size_t capacity, size_t interval) : stat_entry (size_t capacity, size_t interval) :
samples (capacity), sample_interval (interval) samples (capacity), sample_interval (interval)
{ {
} }
@ -516,12 +516,12 @@ public:
* To avoid recursion, the observer callback must only use the received data point snapshop, not query the stat object. * To avoid recursion, the observer callback must only use the received data point snapshop, not query the stat object.
* @param observer The observer receives a snapshot of the current samples. * @param observer The observer receives a snapshot of the current samples.
*/ */
void observe_sample (stat::type type, stat::detail detail, stat::dir dir, std::function<void(boost::circular_buffer<stat_datapoint> &)> observer) void observe_sample (stat::type type, stat::detail detail, stat::dir dir, std::function<void (boost::circular_buffer<stat_datapoint> &)> observer)
{ {
get_entry (key_of (type, detail, dir))->sample_observers.add (observer); get_entry (key_of (type, detail, dir))->sample_observers.add (observer);
} }
void observe_sample (stat::type type, stat::dir dir, std::function<void(boost::circular_buffer<stat_datapoint> &)> observer) void observe_sample (stat::type type, stat::dir dir, std::function<void (boost::circular_buffer<stat_datapoint> &)> observer)
{ {
observe_sample (type, stat::detail::all, dir, observer); observe_sample (type, stat::detail::all, dir, observer);
} }
@ -531,7 +531,7 @@ public:
* To avoid recursion, the observer callback must only use the received counts, not query the stat object. * To avoid recursion, the observer callback must only use the received counts, not query the stat object.
* @param observer The observer receives the old and the new count. * @param observer The observer receives the old and the new count.
*/ */
void observe_count (stat::type type, stat::detail detail, stat::dir dir, std::function<void(uint64_t, uint64_t)> observer) void observe_count (stat::type type, stat::detail detail, stat::dir dir, std::function<void (uint64_t, uint64_t)> observer)
{ {
get_entry (key_of (type, detail, dir))->count_observers.add (observer); get_entry (key_of (type, detail, dir))->count_observers.add (observer);
} }

22
nano/lib/threading.cpp
View file

@ -120,14 +120,14 @@ void nano::thread_attributes::set (boost::thread::attributes & attrs)
} }
nano::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a) : nano::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a) :
io_guard (boost::asio::make_work_guard (io_ctx_a)) io_guard (boost::asio::make_work_guard (io_ctx_a))
{ {
boost::thread::attributes attrs; boost::thread::attributes attrs;
nano::thread_attributes::set (attrs); nano::thread_attributes::set (attrs);
auto count = (is_sanitizer_build && nano::network_constants{}.is_dev_network ()) ? 1 : service_threads_a; // This is a workaround to a bad interaction between TSAN, multiple coroutines, and multiple threads servicing io_context. Only use 1 thread if sanitizers are attached auto count = (is_sanitizer_build && nano::network_constants{}.is_dev_network ()) ? 1 : service_threads_a; // This is a workaround to a bad interaction between TSAN, multiple coroutines, and multiple threads servicing io_context. Only use 1 thread if sanitizers are attached
for (auto i (0u); i < count; ++i) for (auto i (0u); i < count; ++i)
{ {
threads.emplace_back (attrs, [&io_ctx_a]() { threads.emplace_back (attrs, [&io_ctx_a] () {
nano::thread_role::set (nano::thread_role::name::io); nano::thread_role::set (nano::thread_role::name::io);
try try
{ {
@ -197,8 +197,8 @@ void nano::thread_runner::stop_event_processing ()
} }
nano::thread_pool::thread_pool (unsigned num_threads, nano::thread_role::name thread_name) : nano::thread_pool::thread_pool (unsigned num_threads, nano::thread_role::name thread_name) :
num_threads (num_threads), num_threads (num_threads),
thread_pool_m (std::make_unique<boost::asio::thread_pool> (num_threads)) thread_pool_m (std::make_unique<boost::asio::thread_pool> (num_threads))
{ {
set_thread_names (num_threads, thread_name); set_thread_names (num_threads, thread_name);
} }
@ -226,26 +226,26 @@ void nano::thread_pool::stop ()
} }
} }
void nano::thread_pool::push_task (std::function<void()> task) void nano::thread_pool::push_task (std::function<void ()> task)
{ {
++num_tasks; ++num_tasks;
nano::lock_guard<nano::mutex> guard (mutex); nano::lock_guard<nano::mutex> guard (mutex);
if (!stopped) if (!stopped)
{ {
boost::asio::post (*thread_pool_m, [this, task]() { boost::asio::post (*thread_pool_m, [this, task] () {
task (); task ();
--num_tasks; --num_tasks;
}); });
} }
} }
void nano::thread_pool::add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void()> task) void nano::thread_pool::add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void ()> task)
{ {
nano::lock_guard<nano::mutex> guard (mutex); nano::lock_guard<nano::mutex> guard (mutex);
if (!stopped && thread_pool_m) if (!stopped && thread_pool_m)
{ {
auto timer = std::make_shared<boost::asio::steady_timer> (thread_pool_m->get_executor (), expiry_time); auto timer = std::make_shared<boost::asio::steady_timer> (thread_pool_m->get_executor (), expiry_time);
timer->async_wait ([this, task, timer](const boost::system::error_code & ec) { timer->async_wait ([this, task, timer] (const boost::system::error_code & ec) {
if (!ec) if (!ec)
{ {
push_task (task); push_task (task);
@ -270,13 +270,13 @@ void nano::thread_pool::set_thread_names (unsigned num_threads, nano::thread_rol
std::vector<std::promise<void>> promises (num_threads); std::vector<std::promise<void>> promises (num_threads);
std::vector<std::future<void>> futures; std::vector<std::future<void>> futures;
futures.reserve (num_threads); futures.reserve (num_threads);
std::transform (promises.begin (), promises.end (), std::back_inserter (futures), [](auto & promise) { std::transform (promises.begin (), promises.end (), std::back_inserter (futures), [] (auto & promise) {
return promise.get_future (); return promise.get_future ();
}); });
for (auto i = 0u; i < num_threads; ++i) for (auto i = 0u; i < num_threads; ++i)
{ {
boost::asio::post (*thread_pool_m, [& promise = promises[i], thread_name]() { boost::asio::post (*thread_pool_m, [&promise = promises[i], thread_name] () {
nano::thread_role::set (thread_name); nano::thread_role::set (thread_name);
promise.set_value (); promise.set_value ();
}); });
@ -292,6 +292,6 @@ void nano::thread_pool::set_thread_names (unsigned num_threads, nano::thread_rol
std::unique_ptr<nano::container_info_component> nano::collect_container_info (thread_pool & thread_pool, std::string const & name) std::unique_ptr<nano::container_info_component> nano::collect_container_info (thread_pool & thread_pool, std::string const & name)
{ {
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{ "count", thread_pool.num_queued_tasks (), sizeof (std::function<void()>) })); composite->add_component (std::make_unique<container_info_leaf> (container_info{ "count", thread_pool.num_queued_tasks (), sizeof (std::function<void ()>) }));
return composite; return composite;
} }

6
nano/lib/threading.hpp
View file

@ -90,7 +90,7 @@ class relaxed_atomic_integral
public: public:
relaxed_atomic_integral () noexcept = default; relaxed_atomic_integral () noexcept = default;
constexpr relaxed_atomic_integral (T desired) noexcept : constexpr relaxed_atomic_integral (T desired) noexcept :
atomic (desired) atomic (desired)
{ {
} }
@ -169,10 +169,10 @@ public:
~thread_pool (); ~thread_pool ();
/** This will run when there is an available thread for execution */ /** This will run when there is an available thread for execution */
void push_task (std::function<void()>); void push_task (std::function<void ()>);
/** Run a task at a certain point in time */ /** Run a task at a certain point in time */
void add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void()> task); void add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void ()> task);
/** Stops any further pushed tasks from executing */ /** Stops any further pushed tasks from executing */
void stop (); void stop ();

8
nano/lib/timer.cpp
View file

@ -45,7 +45,7 @@ std::string typed_unit ()
template <typename UNIT, typename CLOCK> template <typename UNIT, typename CLOCK>
nano::timer<UNIT, CLOCK>::timer (nano::timer_state state_a, std::string const & description_a) : nano::timer<UNIT, CLOCK>::timer (nano::timer_state state_a, std::string const & description_a) :
desc (description_a) desc (description_a)
{ {
if (state_a == nano::timer_state::started) if (state_a == nano::timer_state::started)
{ {
@ -55,14 +55,14 @@ desc (description_a)
template <typename UNIT, typename CLOCK> template <typename UNIT, typename CLOCK>
nano::timer<UNIT, CLOCK>::timer (std::string const & description_a) : nano::timer<UNIT, CLOCK>::timer (std::string const & description_a) :
desc (description_a) desc (description_a)
{ {
} }
template <typename UNIT, typename CLOCK> template <typename UNIT, typename CLOCK>
nano::timer<UNIT, CLOCK>::timer (std::string const & description_a, nano::timer<UNIT, CLOCK> * parent_a) : nano::timer<UNIT, CLOCK>::timer (std::string const & description_a, nano::timer<UNIT, CLOCK> * parent_a) :
parent (parent_a), parent (parent_a),
desc (description_a) desc (description_a)
{ {
} }

8
nano/lib/tomlconfig.cpp
View file

@ -4,13 +4,13 @@
#include <boost/filesystem/convenience.hpp> #include <boost/filesystem/convenience.hpp>
nano::tomlconfig::tomlconfig () : nano::tomlconfig::tomlconfig () :
tree (cpptoml::make_table ()) tree (cpptoml::make_table ())
{ {
error = std::make_shared<nano::error> (); error = std::make_shared<nano::error> ();
} }
nano::tomlconfig::tomlconfig (std::shared_ptr<cpptoml::table> const & tree_a, std::shared_ptr<nano::error> const & error_a) : nano::tomlconfig::tomlconfig (std::shared_ptr<cpptoml::table> const & tree_a, std::shared_ptr<nano::error> const & error_a) :
nano::configbase (error_a), tree (tree_a) nano::configbase (error_a), tree (tree_a)
{ {
if (!error) if (!error)
{ {
@ -250,7 +250,7 @@ nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string cons
nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string const & key, bool & target, bool default_value) nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string const & key, bool & target, bool default_value)
{ {
auto bool_conv = [this, &target, &key, optional](std::string val) { auto bool_conv = [this, &target, &key, optional] (std::string val) {
if (val == "true") if (val == "true")
{ {
target = true; target = true;
@ -317,7 +317,7 @@ void nano::tomlconfig::erase_defaults (std::shared_ptr<cpptoml::table> const & b
if (arr_other.size () == arr_base.size ()) if (arr_other.size () == arr_base.size ())
{ {
bool equal = std::equal (arr_other.begin (), arr_other.end (), arr_base.begin (), bool equal = std::equal (arr_other.begin (), arr_other.end (), arr_base.begin (),
[](auto const & item1, auto const & item2) -> bool { [] (auto const & item1, auto const & item2) -> bool {
return (item1->template as<std::string> ()->get () == item2->template as<std::string> ()->get ()); return (item1->template as<std::string> ()->get () == item2->template as<std::string> ()->get ());
}); });

2
nano/lib/tomlconfig.hpp
View file

@ -85,7 +85,7 @@ public:
* @param key Array element key. Qualified (dotted) keys are not supported for arrays so this must be called on the correct tomlconfig node. * @param key Array element key. Qualified (dotted) keys are not supported for arrays so this must be called on the correct tomlconfig node.
*/ */
template <typename T> template <typename T>
tomlconfig & array_entries_required (std::string const & key, std::function<void(T)> callback) tomlconfig & array_entries_required (std::string const & key, std::function<void (T)> callback)
{ {
if (tree->contains_qualified (key)) if (tree->contains_qualified (key))
{ {

8
nano/lib/utility.cpp
View file

@ -49,7 +49,7 @@ std::size_t nano::get_filedescriptor_limit ()
} }
nano::container_info_composite::container_info_composite (std::string const & name) : nano::container_info_composite::container_info_composite (std::string const & name) :
name (name) name (name)
{ {
} }
@ -74,7 +74,7 @@ const std::string & nano::container_info_composite::get_name () const
} }
nano::container_info_leaf::container_info_leaf (const container_info & info) : nano::container_info_leaf::container_info_leaf (const container_info & info) :
info (info) info (info)
{ {
} }
@ -131,8 +131,8 @@ void nano::move_all_files_to_dir (boost::filesystem::path const & from, boost::f
void assert_internal (const char * check_expr, const char * func, const char * file, unsigned int line, bool is_release_assert, std::string_view error_msg) void assert_internal (const char * check_expr, const char * func, const char * file, unsigned int line, bool is_release_assert, std::string_view error_msg)
{ {
std::cerr << "Assertion (" << check_expr << ") failed\n" std::cerr << "Assertion (" << check_expr << ") failed\n"
<< func << "\n" << func << "\n"
<< file << ":" << line << "\n"; << file << ":" << line << "\n";
if (!error_msg.empty ()) if (!error_msg.empty ())
{ {
std::cerr << "Error: " << error_msg << "\n"; std::cerr << "Error: " << error_msg << "\n";

4
nano/lib/utility.hpp
View file

@ -146,7 +146,7 @@ template <typename... T>
class observer_set final class observer_set final
{ {
public: public:
void add (std::function<void(T...)> const & observer_a) void add (std::function<void (T...)> const & observer_a)
{ {
nano::lock_guard<nano::mutex> lock (mutex); nano::lock_guard<nano::mutex> lock (mutex);
observers.push_back (observer_a); observers.push_back (observer_a);
@ -160,7 +160,7 @@ public:
} }
} }
nano::mutex mutex{ mutex_identifier (mutexes::observer_set) }; nano::mutex mutex{ mutex_identifier (mutexes::observer_set) };
std::vector<std::function<void(T...)>> observers; std::vector<std::function<void (T...)>> observers;
}; };
template <typename... T> template <typename... T>

16
nano/lib/work.cpp
View file

@ -199,10 +199,10 @@ double nano::denormalized_multiplier (double const multiplier_a, uint64_t const
} }
nano::work_pool::work_pool (unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> opencl_a) : nano::work_pool::work_pool (unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> opencl_a) :
ticket (0), ticket (0),
done (false), done (false),
pow_rate_limiter (pow_rate_limiter_a), pow_rate_limiter (pow_rate_limiter_a),
opencl (opencl_a) opencl (opencl_a)
{ {
static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed"); static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed");
boost::thread::attributes attrs; boost::thread::attributes attrs;
@ -215,7 +215,7 @@ opencl (opencl_a)
} }
for (auto i (0u); i < count; ++i) for (auto i (0u); i < count; ++i)
{ {
threads.emplace_back (attrs, [this, i]() { threads.emplace_back (attrs, [this, i] () {
nano::thread_role::set (nano::thread_role::name::work); nano::thread_role::set (nano::thread_role::name::work);
nano::work_thread_reprioritize (); nano::work_thread_reprioritize ();
loop (i); loop (i);
@ -331,7 +331,7 @@ void nano::work_pool::cancel (nano::root const & root_a)
++ticket; ++ticket;
} }
} }
pending.remove_if ([&root_a](decltype (pending)::value_type const & item_a) { pending.remove_if ([&root_a] (decltype (pending)::value_type const & item_a) {
bool result{ false }; bool result{ false };
if (item_a.item == root_a) if (item_a.item == root_a)
{ {
@ -356,7 +356,7 @@ void nano::work_pool::stop ()
producer_condition.notify_all (); producer_condition.notify_all ();
} }
void nano::work_pool::generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t> const &)> callback_a) void nano::work_pool::generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t> const &)> callback_a)
{ {
debug_assert (!root_a.is_zero ()); debug_assert (!root_a.is_zero ());
if (!threads.empty ()) if (!threads.empty ())
@ -394,7 +394,7 @@ boost::optional<uint64_t> nano::work_pool::generate (nano::work_version const ve
{ {
std::promise<boost::optional<uint64_t>> work; std::promise<boost::optional<uint64_t>> work;
std::future<boost::optional<uint64_t>> future = work.get_future (); std::future<boost::optional<uint64_t>> future = work.get_future ();
generate (version_a, root_a, difficulty_a, [&work](boost::optional<uint64_t> work_a) { generate (version_a, root_a, difficulty_a, [&work] (boost::optional<uint64_t> work_a) {
work.set_value (work_a); work.set_value (work_a);
}); });
result = future.get ().value (); result = future.get ().value ();

8
nano/lib/work.hpp
View file

@ -47,14 +47,14 @@ class opencl_work;
class work_item final class work_item final
{ {
public: public:
work_item (nano::work_version const version_a, nano::root const & item_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t> const &)> const & callback_a) : work_item (nano::work_version const version_a, nano::root const & item_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t> const &)> const & callback_a) :
version (version_a), item (item_a), difficulty (difficulty_a), callback (callback_a) version (version_a), item (item_a), difficulty (difficulty_a), callback (callback_a)
{ {
} }
nano::work_version const version; nano::work_version const version;
nano::root const item; nano::root const item;
uint64_t const difficulty; uint64_t const difficulty;
std::function<void(boost::optional<uint64_t> const &)> const callback; std::function<void (boost::optional<uint64_t> const &)> const callback;
}; };
class work_pool final class work_pool final
{ {
@ -64,7 +64,7 @@ public:
void loop (uint64_t); void loop (uint64_t);
void stop (); void stop ();
void cancel (nano::root const &); void cancel (nano::root const &);
void generate (nano::work_version const, nano::root const &, uint64_t, std::function<void(boost::optional<uint64_t> const &)>); void generate (nano::work_version const, nano::root const &, uint64_t, std::function<void (boost::optional<uint64_t> const &)>);
boost::optional<uint64_t> generate (nano::work_version const, nano::root const &, uint64_t); boost::optional<uint64_t> generate (nano::work_version const, nano::root const &, uint64_t);
// For tests only // For tests only
boost::optional<uint64_t> generate (nano::root const &); boost::optional<uint64_t> generate (nano::root const &);

8
nano/load_test/entry.cpp
View file

@ -163,7 +163,7 @@ boost::property_tree::ptree rpc_request (boost::property_tree::ptree const & req
debug_assert (results.size () == 1); debug_assert (results.size () == 1);
std::promise<boost::optional<boost::property_tree::ptree>> promise; std::promise<boost::optional<boost::property_tree::ptree>> promise;
boost::asio::spawn (ioc, [&ioc, &results, request, &promise](boost::asio::yield_context yield) { boost::asio::spawn (ioc, [&ioc, &results, request, &promise] (boost::asio::yield_context yield) {
socket_type socket (ioc); socket_type socket (ioc);
boost::beast::flat_buffer buffer; boost::beast::flat_buffer buffer;
http::request<http::string_body> req; http::request<http::string_body> req;
@ -377,7 +377,7 @@ int main (int argc, char * const * argv)
boost::asio::io_context ioc; boost::asio::io_context ioc;
debug_assert (!nano::signal_handler_impl); debug_assert (!nano::signal_handler_impl);
nano::signal_handler_impl = [&ioc]() { nano::signal_handler_impl = [&ioc] () {
ioc.stop (); ioc.stop ();
}; };
@ -387,7 +387,7 @@ int main (int argc, char * const * argv)
tcp::resolver resolver{ ioc }; tcp::resolver resolver{ ioc };
auto const primary_node_results = resolver.resolve ("::1", std::to_string (rpc_port_start)); auto const primary_node_results = resolver.resolve ("::1", std::to_string (rpc_port_start));
std::thread t ([send_count, &ioc, &primary_node_results, &resolver, &node_count, &destination_count]() { std::thread t ([send_count, &ioc, &primary_node_results, &resolver, &node_count, &destination_count] () {
for (int i = 0; i < node_count; ++i) for (int i = 0; i < node_count; ++i)
{ {
keepalive_rpc (ioc, primary_node_results, peering_port_start + i); keepalive_rpc (ioc, primary_node_results, peering_port_start + i);
@ -436,7 +436,7 @@ int main (int argc, char * const * argv)
} }
// Send from genesis account to different accounts and receive the funds // Send from genesis account to different accounts and receive the funds
boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining](boost::asio::yield_context yield) { boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining] (boost::asio::yield_context yield) {
send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield); send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield);
}); });
} }

16
nano/nano_node/daemon.cpp
View file

@ -51,10 +51,10 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; nano::logger_mt logger{ config.node.logging.min_time_between_log_output };
boost::asio::io_context io_ctx; boost::asio::io_context io_ctx;
auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger)); auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger));
nano::work_pool opencl_work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) { nano::work_pool opencl_work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a);
} }
: std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr)); : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
try try
{ {
// This avoid a blank prompt during any node initialization delays // This avoid a blank prompt during any node initialization delays
@ -76,9 +76,9 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
{ {
auto network_label = node->network_params.network.get_current_network_as_string (); auto network_label = node->network_params.network.get_current_network_as_string ();
std::cout << "Network: " << network_label << ", version: " << NANO_VERSION_STRING << "\n" std::cout << "Network: " << network_label << ", version: " << NANO_VERSION_STRING << "\n"
<< "Path: " << node->application_path.string () << "\n" << "Path: " << node->application_path.string () << "\n"
<< "Build Info: " << BUILD_INFO << "\n" << "Build Info: " << BUILD_INFO << "\n"
<< "Database backend: " << node->store.vendor_get () << std::endl; << "Database backend: " << node->store.vendor_get () << std::endl;
auto voting (node->wallets.reps ().voting); auto voting (node->wallets.reps ().voting);
if (voting > 1) if (voting > 1)
{ {
@ -114,9 +114,9 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
std::cout << error.get_message () << std::endl; std::cout << error.get_message () << std::endl;
std::exit (1); std::exit (1);
} }
rpc_handler = std::make_unique<nano::inprocess_rpc_handler> (*node, ipc_server, config.rpc, [&ipc_server, &workers = node->workers, &io_ctx]() { rpc_handler = std::make_unique<nano::inprocess_rpc_handler> (*node, ipc_server, config.rpc, [&ipc_server, &workers = node->workers, &io_ctx] () {
ipc_server.stop (); ipc_server.stop ();
workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx]() { workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx] () {
io_ctx.stop (); io_ctx.stop ();
}); });
}); });
@ -137,7 +137,7 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
} }
debug_assert (!nano::signal_handler_impl); debug_assert (!nano::signal_handler_impl);
nano::signal_handler_impl = [&io_ctx]() { nano::signal_handler_impl = [&io_ctx] () {
io_ctx.stop (); io_ctx.stop ();
sig_int_or_term = 1; sig_int_or_term = 1;
}; };

216
nano/nano_node/entry.cpp
View file

@ -172,8 +172,8 @@ int main (int argc, char * const * argv)
auto const ledger_unfiltered = node->ledger.cache.rep_weights.get_rep_amounts (); auto const ledger_unfiltered = node->ledger.cache.rep_weights.get_rep_amounts ();
auto const ledger_height = node->ledger.cache.block_count.load (); auto const ledger_height = node->ledger.cache.block_count.load ();
auto get_total = [](decltype (bootstrap_weights.second) const & reps) -> nano::uint128_union { auto get_total = [] (decltype (bootstrap_weights.second) const & reps) -> nano::uint128_union {
return std::accumulate (reps.begin (), reps.end (), nano::uint128_t{ 0 }, [](auto sum, auto const & rep) { return sum + rep.second; }); return std::accumulate (reps.begin (), reps.end (), nano::uint128_t{ 0 }, [] (auto sum, auto const & rep) { return sum + rep.second; });
}; };
// Hardcoded weights are filtered to a cummulative weight of 99%, need to do the same for ledger weights // Hardcoded weights are filtered to a cummulative weight of 99%, need to do the same for ledger weights
@ -182,7 +182,7 @@ int main (int argc, char * const * argv)
std::vector<std::pair<nano::account, nano::uint128_t>> sorted; std::vector<std::pair<nano::account, nano::uint128_t>> sorted;
sorted.reserve (ledger_unfiltered.size ()); sorted.reserve (ledger_unfiltered.size ());
std::copy (ledger_unfiltered.begin (), ledger_unfiltered.end (), std::back_inserter (sorted)); std::copy (ledger_unfiltered.begin (), ledger_unfiltered.end (), std::back_inserter (sorted));
std::sort (sorted.begin (), sorted.end (), [](auto const & left, auto const & right) { return left.second > right.second; }); std::sort (sorted.begin (), sorted.end (), [] (auto const & left, auto const & right) { return left.second > right.second; });
auto const total_unfiltered = get_total (ledger_unfiltered); auto const total_unfiltered = get_total (ledger_unfiltered);
nano::uint128_t sum{ 0 }; nano::uint128_t sum{ 0 };
auto target = (total_unfiltered.number () / 100) * 99; auto target = (total_unfiltered.number () / 100) * 99;
@ -210,7 +210,7 @@ int main (int argc, char * const * argv)
std::vector<mismatched_t> mismatched; std::vector<mismatched_t> mismatched;
mismatched.reserve (hardcoded.size ()); mismatched.reserve (hardcoded.size ());
std::transform (hardcoded.begin (), hardcoded.end (), std::back_inserter (mismatched), [&ledger](auto const & rep) { std::transform (hardcoded.begin (), hardcoded.end (), std::back_inserter (mismatched), [&ledger] (auto const & rep) {
auto ledger_rep (ledger.find (rep.first)); auto ledger_rep (ledger.find (rep.first));
nano::uint128_t ledger_weight = (ledger_rep == ledger.end () ? 0 : ledger_rep->second); nano::uint128_t ledger_weight = (ledger_rep == ledger.end () ? 0 : ledger_rep->second);
auto absolute = ledger_weight > rep.second ? ledger_weight - rep.second : rep.second - ledger_weight; auto absolute = ledger_weight > rep.second ? ledger_weight - rep.second : rep.second - ledger_weight;
@ -218,12 +218,12 @@ int main (int argc, char * const * argv)
}); });
// Sort by descending difference // Sort by descending difference
std::sort (mismatched.begin (), mismatched.end (), [](mismatched_t const & left, mismatched_t const & right) { return left.diff > right.diff; }); std::sort (mismatched.begin (), mismatched.end (), [] (mismatched_t const & left, mismatched_t const & right) { return left.diff > right.diff; });
nano::uint128_union const mismatch_total = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint128_t{ 0 }, [](auto sum, mismatched_t const & sample) { return sum + sample.diff.number (); }); nano::uint128_union const mismatch_total = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint128_t{ 0 }, [] (auto sum, mismatched_t const & sample) { return sum + sample.diff.number (); });
nano::uint128_union const mismatch_mean = mismatch_total.number () / mismatched.size (); nano::uint128_union const mismatch_mean = mismatch_total.number () / mismatched.size ();
nano::uint512_union mismatch_variance = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint512_t (0), [M = mismatch_mean.number (), N = mismatched.size ()](nano::uint512_t sum, mismatched_t const & sample) { nano::uint512_union mismatch_variance = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint512_t (0), [M = mismatch_mean.number (), N = mismatched.size ()] (nano::uint512_t sum, mismatched_t const & sample) {
auto x = sample.diff.number (); auto x = sample.diff.number ();
nano::uint512_t const mean_diff = x > M ? x - M : M - x; nano::uint512_t const mean_diff = x > M ? x - M : M - x;
nano::uint512_t const sqr = mean_diff * mean_diff; nano::uint512_t const sqr = mean_diff * mean_diff;
@ -235,20 +235,20 @@ int main (int argc, char * const * argv)
auto const outlier_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number () + 1 * mismatch_stddev.number ()); auto const outlier_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number () + 1 * mismatch_stddev.number ());
decltype (mismatched) outliers; decltype (mismatched) outliers;
std::copy_if (mismatched.begin (), mismatched.end (), std::back_inserter (outliers), [outlier_threshold](mismatched_t const & sample) { std::copy_if (mismatched.begin (), mismatched.end (), std::back_inserter (outliers), [outlier_threshold] (mismatched_t const & sample) {
return sample.diff > outlier_threshold; return sample.diff > outlier_threshold;
}); });
auto const newcomer_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number ()); auto const newcomer_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number ());
std::vector<std::pair<nano::account, nano::uint128_t>> newcomers; std::vector<std::pair<nano::account, nano::uint128_t>> newcomers;
std::copy_if (ledger.begin (), ledger.end (), std::back_inserter (newcomers), [&hardcoded](auto const & rep) { std::copy_if (ledger.begin (), ledger.end (), std::back_inserter (newcomers), [&hardcoded] (auto const & rep) {
return !hardcoded.count (rep.first) && rep.second; return !hardcoded.count (rep.first) && rep.second;
}); });
// Sort by descending weight // Sort by descending weight
std::sort (newcomers.begin (), newcomers.end (), [](auto const & left, auto const & right) { return left.second > right.second; }); std::sort (newcomers.begin (), newcomers.end (), [] (auto const & left, auto const & right) { return left.second > right.second; });
auto newcomer_entry = [](auto const & rep) { auto newcomer_entry = [] (auto const & rep) {
return boost::str (boost::format ("representative %1% hardcoded --- ledger %2%") % rep.first.to_account () % nano::uint128_union (rep.second).format_balance (nano::Mxrb_ratio, 0, true)); return boost::str (boost::format ("representative %1% hardcoded --- ledger %2%") % rep.first.to_account () % nano::uint128_union (rep.second).format_balance (nano::Mxrb_ratio, 0, true));
}; };
@ -326,18 +326,18 @@ int main (int argc, char * const * argv)
nano::keypair genesis (key.to_string ()); nano::keypair genesis (key.to_string ());
nano::work_pool work (std::numeric_limits<unsigned>::max ()); nano::work_pool work (std::numeric_limits<unsigned>::max ());
std::cout << "Genesis: " << genesis.prv.to_string () << "\n" std::cout << "Genesis: " << genesis.prv.to_string () << "\n"
<< "Public: " << genesis.pub.to_string () << "\n" << "Public: " << genesis.pub.to_string () << "\n"
<< "Account: " << genesis.pub.to_account () << "\n"; << "Account: " << genesis.pub.to_account () << "\n";
nano::keypair landing; nano::keypair landing;
std::cout << "Landing: " << landing.prv.to_string () << "\n" std::cout << "Landing: " << landing.prv.to_string () << "\n"
<< "Public: " << landing.pub.to_string () << "\n" << "Public: " << landing.pub.to_string () << "\n"
<< "Account: " << landing.pub.to_account () << "\n"; << "Account: " << landing.pub.to_account () << "\n";
for (auto i (0); i != 32; ++i) for (auto i (0); i != 32; ++i)
{ {
nano::keypair rep; nano::keypair rep;
std::cout << "Rep" << i << ": " << rep.prv.to_string () << "\n" std::cout << "Rep" << i << ": " << rep.prv.to_string () << "\n"
<< "Public: " << rep.pub.to_string () << "\n" << "Public: " << rep.pub.to_string () << "\n"
<< "Account: " << rep.pub.to_account () << "\n"; << "Account: " << rep.pub.to_account () << "\n";
} }
nano::network_constants network_constants; nano::network_constants network_constants;
nano::uint128_t balance (std::numeric_limits<nano::uint128_t>::max ()); nano::uint128_t balance (std::numeric_limits<nano::uint128_t>::max ());
@ -610,10 +610,10 @@ int main (int argc, char * const * argv)
nano::logger_mt logger; nano::logger_mt logger;
nano::opencl_config config (platform, device, threads); nano::opencl_config config (platform, device, threads);
auto opencl (nano::opencl_work::create (true, config, logger)); auto opencl (nano::opencl_work::create (true, config, logger));
nano::work_pool work_pool (0, std::chrono::nanoseconds (0), opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) { nano::work_pool work_pool (0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
return opencl->generate_work (version_a, root_a, difficulty_a); return opencl->generate_work (version_a, root_a, difficulty_a);
} }
: std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr)); : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); nano::change_block block (0, 0, nano::keypair ().prv, 0, 0);
std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, network_constants.publish_full.base), 4) % network_constants.publish_full.base); std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, network_constants.publish_full.base), 4) % network_constants.publish_full.base);
for (uint64_t i (0); true; ++i) for (uint64_t i (0); true; ++i)
@ -628,14 +628,14 @@ int main (int argc, char * const * argv)
else else
{ {
std::cout << "Not available device id\n" std::cout << "Not available device id\n"
<< std::endl; << std::endl;
result = -1; result = -1;
} }
} }
else else
{ {
std::cout << "Not available platform id\n" std::cout << "Not available platform id\n"
<< std::endl; << std::endl;
result = -1; result = -1;
} }
} }
@ -655,7 +655,7 @@ int main (int argc, char * const * argv)
boost::stacktrace::stacktrace st = boost::stacktrace::stacktrace::from_dump (ifs); boost::stacktrace::stacktrace st = boost::stacktrace::stacktrace::from_dump (ifs);
std::cout << "Latest crash backtrace:\n" std::cout << "Latest crash backtrace:\n"
<< st << std::endl; << st << std::endl;
} }
} }
else if (vm.count ("debug_generate_crash_report")) else if (vm.count ("debug_generate_crash_report"))
@ -782,7 +782,7 @@ int main (int argc, char * const * argv)
// and inform the user that it needs installing // and inform the user that it needs installing
std::vector<int> system_codes; std::vector<int> system_codes;
auto run_addr2line = [&backtrace_addresses, &base_addresses, &system_codes, &crash_report_filename](bool use_relative_addresses) { auto run_addr2line = [&backtrace_addresses, &base_addresses, &system_codes, &crash_report_filename] (bool use_relative_addresses) {
for (auto backtrace_address : backtrace_addresses) for (auto backtrace_address : backtrace_addresses)
{ {
// Find the closest address to it // Find the closest address to it
@ -809,7 +809,7 @@ int main (int argc, char * const * argv)
{ {
std::ofstream ofs (crash_report_filename, std::ios_base::out | std::ios_base::app); std::ofstream ofs (crash_report_filename, std::ios_base::out | std::ios_base::app);
ofs << std::endl ofs << std::endl
<< "Using relative addresses:" << std::endl; // Add an empty line to separate the absolute & relative output << "Using relative addresses:" << std::endl; // Add an empty line to separate the absolute & relative output
} }
// Now run using relative addresses. This will give actual results for other dlls, the results from the nano_node executable. // Now run using relative addresses. This will give actual results for other dlls, the results from the nano_node executable.
@ -912,27 +912,27 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - 1000000000; genesis_balance = genesis_balance - 1000000000;
auto send = builder.state () auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub) .account (dev_params.ledger.dev_genesis_key.pub)
.previous (genesis_latest) .previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub) .representative (dev_params.ledger.dev_genesis_key.pub)
.balance (genesis_balance) .balance (genesis_balance)
.link (keys[i].pub) .link (keys[i].pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
genesis_latest = send->hash (); genesis_latest = send->hash ();
blocks.push_back (std::move (send)); blocks.push_back (std::move (send));
auto open = builder.state () auto open = builder.state ()
.account (keys[i].pub) .account (keys[i].pub)
.previous (0) .previous (0)
.representative (keys[i].pub) .representative (keys[i].pub)
.balance (balances[i]) .balance (balances[i])
.link (genesis_latest) .link (genesis_latest)
.sign (keys[i].prv, keys[i].pub) .sign (keys[i].prv, keys[i].pub)
.work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
frontiers[i] = open->hash (); frontiers[i] = open->hash ();
blocks.push_back (std::move (open)); blocks.push_back (std::move (open));
@ -946,14 +946,14 @@ int main (int argc, char * const * argv)
--balances[j]; --balances[j];
auto send = builder.state () auto send = builder.state ()
.account (keys[j].pub) .account (keys[j].pub)
.previous (frontiers[j].as_block_hash ()) .previous (frontiers[j].as_block_hash ())
.representative (keys[j].pub) .representative (keys[j].pub)
.balance (balances[j]) .balance (balances[j])
.link (keys[other].pub) .link (keys[other].pub)
.sign (keys[j].prv, keys[j].pub) .sign (keys[j].prv, keys[j].pub)
.work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
frontiers[j] = send->hash (); frontiers[j] = send->hash ();
blocks.push_back (std::move (send)); blocks.push_back (std::move (send));
@ -961,14 +961,14 @@ int main (int argc, char * const * argv)
++balances[other]; ++balances[other];
auto receive = builder.state () auto receive = builder.state ()
.account (keys[other].pub) .account (keys[other].pub)
.previous (frontiers[other].as_block_hash ()) .previous (frontiers[other].as_block_hash ())
.representative (keys[other].pub) .representative (keys[other].pub)
.balance (balances[other]) .balance (balances[other])
.link (frontiers[j].as_block_hash ()) .link (frontiers[j].as_block_hash ())
.sign (keys[other].prv, keys[other].pub) .sign (keys[other].prv, keys[other].pub)
.work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
frontiers[other] = receive->hash (); frontiers[other] = receive->hash ();
blocks.push_back (std::move (receive)); blocks.push_back (std::move (receive));
@ -1027,27 +1027,27 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - balance; genesis_balance = genesis_balance - balance;
auto send = builder.state () auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub) .account (dev_params.ledger.dev_genesis_key.pub)
.previous (genesis_latest) .previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub) .representative (dev_params.ledger.dev_genesis_key.pub)
.balance (genesis_balance) .balance (genesis_balance)
.link (keys[i].pub) .link (keys[i].pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
genesis_latest = send->hash (); genesis_latest = send->hash ();
node->ledger.process (transaction, *send); node->ledger.process (transaction, *send);
auto open = builder.state () auto open = builder.state ()
.account (keys[i].pub) .account (keys[i].pub)
.previous (0) .previous (0)
.representative (keys[i].pub) .representative (keys[i].pub)
.balance (balance) .balance (balance)
.link (genesis_latest) .link (genesis_latest)
.sign (keys[i].prv, keys[i].pub) .sign (keys[i].prv, keys[i].pub)
.work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
node->ledger.process (transaction, *open); node->ledger.process (transaction, *open);
} }
@ -1059,14 +1059,14 @@ int main (int argc, char * const * argv)
nano::keypair destination; nano::keypair destination;
auto send = builder.state () auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub) .account (dev_params.ledger.dev_genesis_key.pub)
.previous (genesis_latest) .previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub) .representative (dev_params.ledger.dev_genesis_key.pub)
.balance (genesis_balance) .balance (genesis_balance)
.link (destination.pub) .link (destination.pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build (); .build ();
genesis_latest = send->hash (); genesis_latest = send->hash ();
blocks.push_back (std::move (send)); blocks.push_back (std::move (send));
@ -1166,26 +1166,26 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - 1; genesis_balance = genesis_balance - 1;
auto send = builder.state () auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub) .account (dev_params.ledger.dev_genesis_key.pub)
.previous (genesis_latest) .previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub) .representative (dev_params.ledger.dev_genesis_key.pub)
.balance (genesis_balance) .balance (genesis_balance)
.link (key.pub) .link (key.pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1)) .work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1))
.build (); .build ();
genesis_latest = send->hash (); genesis_latest = send->hash ();
auto open = builder.state () auto open = builder.state ()
.account (key.pub) .account (key.pub)
.previous (0) .previous (0)
.representative (key.pub) .representative (key.pub)
.balance (1) .balance (1)
.link (genesis_latest) .link (genesis_latest)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*work.generate (nano::work_version::work_1, key.pub, dev_params.network.publish_thresholds.epoch_1)) .work (*work.generate (nano::work_version::work_1, key.pub, dev_params.network.publish_thresholds.epoch_1))
.build (); .build ();
blocks.push_back (std::move (send)); blocks.push_back (std::move (send));
blocks.push_back (std::move (open)); blocks.push_back (std::move (open));
@ -1232,7 +1232,7 @@ int main (int argc, char * const * argv)
if (error) if (error)
{ {
std::cerr << "\n" std::cerr << "\n"
<< error.get_message () << std::endl; << error.get_message () << std::endl;
std::exit (1); std::exit (1);
} }
else else
@ -1321,7 +1321,7 @@ int main (int argc, char * const * argv)
command_l << rpc_input_l; command_l << rpc_input_l;
} }
auto response_handler_l ([](std::string const & response_a) { auto response_handler_l ([] (std::string const & response_a) {
std::cout << response_a; std::cout << response_a;
// Terminate as soon as we have the result, even if background threads (like work generation) are running. // Terminate as soon as we have the result, even if background threads (like work generation) are running.
std::exit (0); std::exit (0);
@ -1367,7 +1367,7 @@ int main (int argc, char * const * argv)
std::atomic<uint64_t> block_count (0); std::atomic<uint64_t> block_count (0);
std::atomic<uint64_t> errors (0); std::atomic<uint64_t> errors (0);
auto print_error_message = [&silent, &errors](std::string const & error_message_a) { auto print_error_message = [&silent, &errors] (std::string const & error_message_a) {
if (!silent) if (!silent)
{ {
static nano::mutex cerr_mutex; static nano::mutex cerr_mutex;
@ -1377,10 +1377,10 @@ int main (int argc, char * const * argv)
++errors; ++errors;
}; };
auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished](const auto & function_a, auto & deque_a) { auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished] (const auto & function_a, auto & deque_a) {
for (auto i (0U); i < threads_count; ++i) for (auto i (0U); i < threads_count; ++i)
{ {
threads.emplace_back ([&function_a, node, &mutex, &condition, &finished, &deque_a]() { threads.emplace_back ([&function_a, node, &mutex, &condition, &finished, &deque_a] () {
auto transaction (node->store.tx_begin_read ()); auto transaction (node->store.tx_begin_read ());
nano::unique_lock<nano::mutex> lock (mutex); nano::unique_lock<nano::mutex> lock (mutex);
while (!deque_a.empty () || !finished) while (!deque_a.empty () || !finished)
@ -1402,7 +1402,7 @@ int main (int argc, char * const * argv)
} }
}; };
auto check_account = [&print_error_message, &silent, &count, &block_count](std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::account const & account, nano::account_info const & info) { auto check_account = [&print_error_message, &silent, &count, &block_count] (std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::account const & account, nano::account_info const & info) {
++count; ++count;
if (!silent && (count % 20000) == 0) if (!silent && (count % 20000) == 0)
{ {
@ -1676,7 +1676,7 @@ int main (int argc, char * const * argv)
finished = false; finished = false;
std::deque<std::pair<nano::pending_key, nano::pending_info>> pending; std::deque<std::pair<nano::pending_key, nano::pending_info>> pending;
auto check_pending = [&print_error_message, &silent, &count](std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::pending_key const & key, nano::pending_info const & info) { auto check_pending = [&print_error_message, &silent, &count] (std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::pending_key const & key, nano::pending_info const & info) {
++count; ++count;
if (!silent && (count % 500000) == 0) if (!silent && (count % 500000) == 0)
{ {
@ -1912,7 +1912,7 @@ int main (int argc, char * const * argv)
nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count); nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count);
using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type; using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type;
node->store.accounts_for_each_par ( node->store.accounts_for_each_par (
[&opened_account_versions_shared, epoch_count](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) { [&opened_account_versions_shared, epoch_count] (nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) {
// First cache locally // First cache locally
opened_account_versions_t opened_account_versions_l (epoch_count); opened_account_versions_t opened_account_versions_l (epoch_count);
for (; i != n; ++i) for (; i != n; ++i)
@ -1949,7 +1949,7 @@ int main (int argc, char * const * argv)
nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared; nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared;
using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type; using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type;
node->store.pending_for_each_par ( node->store.pending_for_each_par (
[&unopened_highest_pending_shared, &opened_accounts](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::pending_key, nano::pending_info> i, nano::store_iterator<nano::pending_key, nano::pending_info> n) { [&unopened_highest_pending_shared, &opened_accounts] (nano::read_transaction const & /*unused*/, nano::store_iterator<nano::pending_key, nano::pending_info> i, nano::store_iterator<nano::pending_key, nano::pending_info> n) {
// First cache locally // First cache locally
unopened_highest_pending_t unopened_highest_pending_l; unopened_highest_pending_t unopened_highest_pending_l;
for (; i != n; ++i) for (; i != n; ++i)
@ -1975,7 +1975,7 @@ int main (int argc, char * const * argv)
} }
}); });
auto output_account_version_number = [](auto version, auto num_accounts) { auto output_account_version_number = [] (auto version, auto num_accounts) {
std::cout << "Account version " << version << " num accounts: " << num_accounts << "\n"; std::cout << "Account version " << version << " num accounts: " << num_accounts << "\n";
}; };
@ -2021,7 +2021,7 @@ int main (int argc, char * const * argv)
else if (vm.count ("version")) else if (vm.count ("version"))
{ {
std::cout << "Version " << NANO_VERSION_STRING << "\n" std::cout << "Version " << NANO_VERSION_STRING << "\n"
<< "Build Info " << BUILD_INFO << std::endl; << "Build Info " << BUILD_INFO << std::endl;
} }
else else
{ {
@ -2041,7 +2041,7 @@ std::istream & operator>> (std::istream & in, uint64_from_hex & out_val)
} }
address_library_pair::address_library_pair (uint64_t address, std::string library) : address_library_pair::address_library_pair (uint64_t address, std::string library) :
address (address), library (library) address (address), library (library)
{ {
} }

4
nano/nano_rpc/entry.cpp
View file

@ -54,7 +54,7 @@ void run (boost::filesystem::path const & data_path, std::vector<std::string> co
rpc->start (); rpc->start ();
debug_assert (!nano::signal_handler_impl); debug_assert (!nano::signal_handler_impl);
nano::signal_handler_impl = [&io_ctx]() { nano::signal_handler_impl = [&io_ctx] () {
io_ctx.stop (); io_ctx.stop ();
sig_int_or_term = 1; sig_int_or_term = 1;
}; };
@ -136,7 +136,7 @@ int main (int argc, char * const * argv)
else if (vm.count ("version")) else if (vm.count ("version"))
{ {
std::cout << "Version " << NANO_VERSION_STRING << "\n" std::cout << "Version " << NANO_VERSION_STRING << "\n"
<< "Build Info " << BUILD_INFO << std::endl; << "Build Info " << BUILD_INFO << std::endl;
} }
else else
{ {

8
nano/nano_wallet/entry.cpp
View file

@ -107,10 +107,10 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
std::shared_ptr<nano_qt::wallet> gui; std::shared_ptr<nano_qt::wallet> gui;
nano::set_application_icon (application); nano::set_application_icon (application);
auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger)); auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger));
nano::work_pool work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) { nano::work_pool work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
return opencl->generate_work (version_a, root_a, difficulty_a); return opencl->generate_work (version_a, root_a, difficulty_a);
} }
: std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr)); : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
node = std::make_shared<nano::node> (io_ctx, data_path, config.node, work, flags); node = std::make_shared<nano::node> (io_ctx, data_path, config.node, work, flags);
if (!node->init_error ()) if (!node->init_error ())
{ {
@ -189,7 +189,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
rpc_process = std::make_unique<boost::process::child> (config.rpc.child_process.rpc_path, "--daemon", "--data_path", data_path, "--network", network); rpc_process = std::make_unique<boost::process::child> (config.rpc.child_process.rpc_path, "--daemon", "--data_path", data_path, "--network", network);
} }
} }
QObject::connect (&application, &QApplication::aboutToQuit, [&]() { QObject::connect (&application, &QApplication::aboutToQuit, [&] () {
ipc.stop (); ipc.stop ();
node->stop (); node->stop ();
if (rpc) if (rpc)
@ -209,7 +209,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
#endif #endif
runner.stop_event_processing (); runner.stop_event_processing ();
}); });
application.postEvent (&processor, new nano_qt::eventloop_event ([&]() { application.postEvent (&processor, new nano_qt::eventloop_event ([&] () {
gui = std::make_shared<nano_qt::wallet> (application, processor, *node, wallet, wallet_config.account); gui = std::make_shared<nano_qt::wallet> (application, processor, *node, wallet, wallet_config.account);
splash->close (); splash->close ();
gui->start (); gui->start ();

30
nano/node/active_transactions.cpp
View file

@ -19,18 +19,18 @@ size_t constexpr nano::active_transactions::max_active_elections_frontier_insert
constexpr std::chrono::minutes nano::active_transactions::expired_optimistic_election_info_cutoff; constexpr std::chrono::minutes nano::active_transactions::expired_optimistic_election_info_cutoff;
nano::active_transactions::active_transactions (nano::node & node_a, nano::confirmation_height_processor & confirmation_height_processor_a) : nano::active_transactions::active_transactions (nano::node & node_a, nano::confirmation_height_processor & confirmation_height_processor_a) :
confirmation_height_processor (confirmation_height_processor_a), confirmation_height_processor (confirmation_height_processor_a),
node (node_a), node (node_a),
multipliers_cb (20, 1.), multipliers_cb (20, 1.),
trended_active_multiplier (1.0), trended_active_multiplier (1.0),
generator (node_a.config, node_a.ledger, node_a.wallets, node_a.vote_processor, node_a.history, node_a.network, node_a.stats), generator (node_a.config, node_a.ledger, node_a.wallets, node_a.vote_processor, node_a.history, node_a.network, node_a.stats),
check_all_elections_period (node_a.network_params.network.is_dev_network () ? 10ms : 5s), check_all_elections_period (node_a.network_params.network.is_dev_network () ? 10ms : 5s),
election_time_to_live (node_a.network_params.network.is_dev_network () ? 0s : 2s), election_time_to_live (node_a.network_params.network.is_dev_network () ? 0s : 2s),
prioritized_cutoff (std::max<size_t> (1, node_a.config.active_elections_size / 10)), prioritized_cutoff (std::max<size_t> (1, node_a.config.active_elections_size / 10)),
thread ([this] () { thread ([this] () {
nano::thread_role::set (nano::thread_role::name::request_loop); nano::thread_role::set (nano::thread_role::name::request_loop);
request_loop (); request_loop ();
}) })
{ {
// Register a callback which will get called after a block is cemented // Register a callback which will get called after a block is cemented
confirmation_height_processor.add_cemented_observer ([this] (std::shared_ptr<nano::block> const & callback_block_a) { confirmation_height_processor.add_cemented_observer ([this] (std::shared_ptr<nano::block> const & callback_block_a) {
@ -1542,13 +1542,13 @@ size_t nano::active_transactions::election_winner_details_size ()
} }
nano::cementable_account::cementable_account (nano::account const & account_a, size_t blocks_uncemented_a) : nano::cementable_account::cementable_account (nano::account const & account_a, size_t blocks_uncemented_a) :
account (account_a), blocks_uncemented (blocks_uncemented_a) account (account_a), blocks_uncemented (blocks_uncemented_a)
{ {
} }
nano::expired_optimistic_election_info::expired_optimistic_election_info (std::chrono::steady_clock::time_point expired_time_a, nano::account account_a) : nano::expired_optimistic_election_info::expired_optimistic_election_info (std::chrono::steady_clock::time_point expired_time_a, nano::account account_a) :
expired_time (expired_time_a), expired_time (expired_time_a),
account (account_a) account (account_a)
{ {
} }

6
nano/node/active_transactions.hpp
View file

@ -68,9 +68,9 @@ class inactive_cache_information final
public: public:
inactive_cache_information () = default; inactive_cache_information () = default;
inactive_cache_information (std::chrono::steady_clock::time_point arrival, nano::block_hash hash, nano::account initial_rep_a, uint64_t initial_timestamp_a, nano::inactive_cache_status status) : inactive_cache_information (std::chrono::steady_clock::time_point arrival, nano::block_hash hash, nano::account initial_rep_a, uint64_t initial_timestamp_a, nano::inactive_cache_status status) :
arrival (arrival), arrival (arrival),
hash (hash), hash (hash),
status (status) status (status)
{ {
voters.reserve (8); voters.reserve (8);
voters.emplace_back (initial_rep_a, initial_timestamp_a); voters.emplace_back (initial_rep_a, initial_timestamp_a);

28
nano/node/blockprocessor.cpp
View file

@ -11,7 +11,7 @@
std::chrono::milliseconds constexpr nano::block_processor::confirmation_request_delay; std::chrono::milliseconds constexpr nano::block_processor::confirmation_request_delay;
nano::block_post_events::block_post_events (std::function<nano::read_transaction ()> && get_transaction_a) : nano::block_post_events::block_post_events (std::function<nano::read_transaction ()> && get_transaction_a) :
get_transaction (std::move (get_transaction_a)) get_transaction (std::move (get_transaction_a))
{ {
} }
@ -26,15 +26,15 @@ nano::block_post_events::~block_post_events ()
} }
nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) : nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) :
next_log (std::chrono::steady_clock::now ()), next_log (std::chrono::steady_clock::now ()),
node (node_a), node (node_a),
write_database_queue (write_database_queue_a), write_database_queue (write_database_queue_a),
state_block_signature_verification (node.checker, node.ledger.network_params.ledger.epochs, node.config, node.logger, node.flags.block_processor_verification_size) state_block_signature_verification (node.checker, node.ledger.network_params.ledger.epochs, node.config, node.logger, node.flags.block_processor_verification_size)
{ {
state_block_signature_verification.blocks_verified_callback = [this](std::deque<std::pair<nano::unchecked_info, bool>> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) { state_block_signature_verification.blocks_verified_callback = [this] (std::deque<std::pair<nano::unchecked_info, bool>> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures); this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures);
}; };
state_block_signature_verification.transition_inactive_callback = [this]() { state_block_signature_verification.transition_inactive_callback = [this] () {
if (this->flushing) if (this->flushing)
{ {
{ {
@ -242,7 +242,7 @@ void nano::block_processor::process_verified_state_blocks (std::deque<std::pair<
void nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock_a) void nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock_a)
{ {
auto scoped_write_guard = write_database_queue.wait (nano::writer::process_batch); auto scoped_write_guard = write_database_queue.wait (nano::writer::process_batch);
block_post_events post_events ([& store = node.store] { return store.tx_begin_read (); }); block_post_events post_events ([&store = node.store] { return store.tx_begin_read (); });
auto transaction (node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending, tables::unchecked })); auto transaction (node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending, tables::unchecked }));
nano::timer<std::chrono::milliseconds> timer_l; nano::timer<std::chrono::milliseconds> timer_l;
lock_a.lock (); lock_a.lock ();
@ -386,7 +386,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
} }
if ((info_a.modified > nano::seconds_since_epoch () - 300 && node.block_arrival.recent (hash)) || forced_a) if ((info_a.modified > nano::seconds_since_epoch () - 300 && node.block_arrival.recent (hash)) || forced_a)
{ {
events_a.events.emplace_back ([this, hash, block = info_a.block, result, watch_work_a, origin_a](nano::transaction const & post_event_transaction_a) { process_live (post_event_transaction_a, hash, block, result, watch_work_a, origin_a); }); events_a.events.emplace_back ([this, hash, block = info_a.block, result, watch_work_a, origin_a] (nano::transaction const & post_event_transaction_a) { process_live (post_event_transaction_a, hash, block, result, watch_work_a, origin_a); });
} }
queue_unchecked (transaction_a, hash); queue_unchecked (transaction_a, hash);
/* For send blocks check epoch open unchecked (gap pending). /* For send blocks check epoch open unchecked (gap pending).
@ -415,7 +415,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
nano::unchecked_key unchecked_key (block->previous (), hash); nano::unchecked_key unchecked_key (block->previous (), hash);
node.store.unchecked_put (transaction_a, unchecked_key, info_a); node.store.unchecked_put (transaction_a, unchecked_key, info_a);
events_a.events.emplace_back ([this, hash](nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); });
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous);
break; break;
@ -435,7 +435,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(block)), hash); nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(block)), hash);
node.store.unchecked_put (transaction_a, unchecked_key, info_a); node.store.unchecked_put (transaction_a, unchecked_key, info_a);
events_a.events.emplace_back ([this, hash](nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); });
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break; break;
@ -464,7 +464,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{ {
node.logger.try_log (boost::str (boost::format ("Old for: %1%") % hash.to_string ())); node.logger.try_log (boost::str (boost::format ("Old for: %1%") % hash.to_string ()));
} }
events_a.events.emplace_back ([this, block = info_a.block, origin_a](nano::transaction const & post_event_transaction_a) { process_old (post_event_transaction_a, block, origin_a); }); events_a.events.emplace_back ([this, block = info_a.block, origin_a] (nano::transaction const & post_event_transaction_a) { process_old (post_event_transaction_a, block, origin_a); });
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old);
break; break;
} }
@ -474,7 +474,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{ {
node.logger.try_log (boost::str (boost::format ("Bad signature for: %1%") % hash.to_string ())); node.logger.try_log (boost::str (boost::format ("Bad signature for: %1%") % hash.to_string ()));
} }
events_a.events.emplace_back ([this, hash, info_a](nano::transaction const & /* unused */) { requeue_invalid (hash, info_a); }); events_a.events.emplace_back ([this, hash, info_a] (nano::transaction const & /* unused */) { requeue_invalid (hash, info_a); });
break; break;
} }
case nano::process_result::negative_spend: case nano::process_result::negative_spend:
@ -496,7 +496,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
case nano::process_result::fork: case nano::process_result::fork:
{ {
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork);
events_a.events.emplace_back ([this, block](nano::transaction const &) { this->node.active.publish (block); }); events_a.events.emplace_back ([this, block] (nano::transaction const &) { this->node.active.publish (block); });
if (node.config.logging.ledger_logging ()) if (node.config.logging.ledger_logging ())
{ {
node.logger.try_log (boost::str (boost::format ("Fork for: %1% root: %2%") % hash.to_string () % block->root ().to_string ())); node.logger.try_log (boost::str (boost::format ("Fork for: %1% root: %2%") % hash.to_string () % block->root ().to_string ()));

2
nano/node/blockprocessor.hpp
View file

@ -33,7 +33,7 @@ class block_post_events final
public: public:
explicit block_post_events (std::function<nano::read_transaction ()> &&); explicit block_post_events (std::function<nano::read_transaction ()> &&);
~block_post_events (); ~block_post_events ();
std::deque<std::function<void(nano::read_transaction const &)>> events; std::deque<std::function<void (nano::read_transaction const &)>> events;
private: private:
std::function<nano::read_transaction ()> get_transaction; std::function<nano::read_transaction ()> get_transaction;

10
nano/node/bootstrap/bootstrap.cpp
View file

@ -10,16 +10,16 @@
#include <algorithm> #include <algorithm>
nano::bootstrap_initiator::bootstrap_initiator (nano::node & node_a) : nano::bootstrap_initiator::bootstrap_initiator (nano::node & node_a) :
node (node_a) node (node_a)
{ {
connections = std::make_shared<nano::bootstrap_connections> (node); connections = std::make_shared<nano::bootstrap_connections> (node);
bootstrap_initiator_threads.push_back (boost::thread ([this]() { bootstrap_initiator_threads.push_back (boost::thread ([this] () {
nano::thread_role::set (nano::thread_role::name::bootstrap_connections); nano::thread_role::set (nano::thread_role::name::bootstrap_connections);
connections->run (); connections->run ();
})); }));
for (size_t i = 0; i < node.config.bootstrap_initiator_threads; ++i) for (size_t i = 0; i < node.config.bootstrap_initiator_threads; ++i)
{ {
bootstrap_initiator_threads.push_back (boost::thread ([this]() { bootstrap_initiator_threads.push_back (boost::thread ([this] () {
nano::thread_role::set (nano::thread_role::name::bootstrap_initiator); nano::thread_role::set (nano::thread_role::name::bootstrap_initiator);
run_bootstrap (); run_bootstrap ();
})); }));
@ -157,7 +157,7 @@ void nano::bootstrap_initiator::lazy_requeue (nano::block_hash const & hash_a, n
} }
} }
void nano::bootstrap_initiator::add_observer (std::function<void(bool)> const & observer_a) void nano::bootstrap_initiator::add_observer (std::function<void (bool)> const & observer_a)
{ {
nano::lock_guard<nano::mutex> lock (observers_mutex); nano::lock_guard<nano::mutex> lock (observers_mutex);
observers.push_back (observer_a); observers.push_back (observer_a);
@ -327,7 +327,7 @@ void nano::pulls_cache::add (nano::pull_info const & pull_a)
else else
{ {
// Update existing pull // Update existing pull
cache.get<account_head_tag> ().modify (existing, [pull_a](nano::cached_pulls & cache_a) { cache.get<account_head_tag> ().modify (existing, [pull_a] (nano::cached_pulls & cache_a) {
cache_a.time = std::chrono::steady_clock::now (); cache_a.time = std::chrono::steady_clock::now ();
cache_a.new_head = pull_a.head; cache_a.new_head = pull_a.head;
}); });

4
nano/node/bootstrap/bootstrap.hpp
View file

@ -88,7 +88,7 @@ public:
void run_bootstrap (); void run_bootstrap ();
void lazy_requeue (nano::block_hash const &, nano::block_hash const &, bool); void lazy_requeue (nano::block_hash const &, nano::block_hash const &, bool);
void notify_listeners (bool); void notify_listeners (bool);
void add_observer (std::function<void(bool)> const &); void add_observer (std::function<void (bool)> const &);
bool in_progress (); bool in_progress ();
std::shared_ptr<nano::bootstrap_connections> connections; std::shared_ptr<nano::bootstrap_connections> connections;
std::shared_ptr<nano::bootstrap_attempt> new_attempt (); std::shared_ptr<nano::bootstrap_attempt> new_attempt ();
@ -110,7 +110,7 @@ private:
nano::mutex mutex; nano::mutex mutex;
nano::condition_variable condition; nano::condition_variable condition;
nano::mutex observers_mutex; nano::mutex observers_mutex;
std::vector<std::function<void(bool)>> observers; std::vector<std::function<void (bool)>> observers;
std::vector<boost::thread> bootstrap_initiator_threads; std::vector<boost::thread> bootstrap_initiator_threads;
friend std::unique_ptr<container_info_component> collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name); friend std::unique_ptr<container_info_component> collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name);

8
nano/node/bootstrap/bootstrap_attempt.cpp
View file

@ -16,10 +16,10 @@ constexpr unsigned nano::bootstrap_limits::requeued_pulls_limit;
constexpr unsigned nano::bootstrap_limits::requeued_pulls_limit_dev; constexpr unsigned nano::bootstrap_limits::requeued_pulls_limit_dev;
nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr<nano::node> const & node_a, nano::bootstrap_mode mode_a, uint64_t incremental_id_a, std::string id_a) : nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr<nano::node> const & node_a, nano::bootstrap_mode mode_a, uint64_t incremental_id_a, std::string id_a) :
node (node_a), node (node_a),
incremental_id (incremental_id_a), incremental_id (incremental_id_a),
id (id_a), id (id_a),
mode (mode_a) mode (mode_a)
{ {
if (id.empty ()) if (id.empty ())
{ {

74
nano/node/bootstrap/bootstrap_bulk_pull.cpp
View file

@ -8,23 +8,23 @@
#include <boost/format.hpp> #include <boost/format.hpp>
nano::pull_info::pull_info (nano::hash_or_account const & account_or_head_a, nano::block_hash const & head_a, nano::block_hash const & end_a, uint64_t bootstrap_id_a, count_t count_a, unsigned retry_limit_a) : nano::pull_info::pull_info (nano::hash_or_account const & account_or_head_a, nano::block_hash const & head_a, nano::block_hash const & end_a, uint64_t bootstrap_id_a, count_t count_a, unsigned retry_limit_a) :
account_or_head (account_or_head_a), account_or_head (account_or_head_a),
head (head_a), head (head_a),
head_original (head_a), head_original (head_a),
end (end_a), end (end_a),
count (count_a), count (count_a),
retry_limit (retry_limit_a), retry_limit (retry_limit_a),
bootstrap_id (bootstrap_id_a) bootstrap_id (bootstrap_id_a)
{ {
} }
nano::bulk_pull_client::bulk_pull_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::pull_info const & pull_a) : nano::bulk_pull_client::bulk_pull_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::pull_info const & pull_a) :
connection (connection_a), connection (connection_a),
attempt (attempt_a), attempt (attempt_a),
known_account (0), known_account (0),
pull (pull_a), pull (pull_a),
pull_blocks (0), pull_blocks (0),
unexpected_count (0) unexpected_count (0)
{ {
attempt->condition.notify_all (); attempt->condition.notify_all ();
} }
@ -83,7 +83,7 @@ void nano::bulk_pull_client::request ()
} }
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send ( connection->channel->send (
req, [this_l](boost::system::error_code const & ec, size_t size_a) { req, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->throttled_receive_block (); this_l->throttled_receive_block ();
@ -110,7 +110,7 @@ void nano::bulk_pull_client::throttled_receive_block ()
else else
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l]() { connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l] () {
if (!this_l->connection->pending_stop && !this_l->attempt->stopped) if (!this_l->connection->pending_stop && !this_l->attempt->stopped)
{ {
this_l->throttled_receive_block (); this_l->throttled_receive_block ();
@ -122,7 +122,7 @@ void nano::bulk_pull_client::throttled_receive_block ()
void nano::bulk_pull_client::receive_block () void nano::bulk_pull_client::receive_block ()
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->socket->async_read (connection->receive_buffer, 1, [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (connection->receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->received_type (); this_l->received_type ();
@ -149,35 +149,35 @@ void nano::bulk_pull_client::received_type ()
{ {
case nano::block_type::send: case nano::block_type::send:
{ {
socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
} }
case nano::block_type::receive: case nano::block_type::receive:
{ {
socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
} }
case nano::block_type::open: case nano::block_type::open:
{ {
socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
} }
case nano::block_type::change: case nano::block_type::change:
{ {
socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
} }
case nano::block_type::state: case nano::block_type::state:
{ {
socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
@ -285,10 +285,10 @@ void nano::bulk_pull_client::received_block (boost::system::error_code const & e
} }
nano::bulk_pull_account_client::bulk_pull_account_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::account const & account_a) : nano::bulk_pull_account_client::bulk_pull_account_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::account const & account_a) :
connection (connection_a), connection (connection_a),
attempt (attempt_a), attempt (attempt_a),
account (account_a), account (account_a),
pull_blocks (0) pull_blocks (0)
{ {
attempt->condition.notify_all (); attempt->condition.notify_all ();
} }
@ -314,7 +314,7 @@ void nano::bulk_pull_account_client::request ()
} }
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send ( connection->channel->send (
req, [this_l](boost::system::error_code const & ec, size_t size_a) { req, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->receive_pending (); this_l->receive_pending ();
@ -336,7 +336,7 @@ void nano::bulk_pull_account_client::receive_pending ()
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint128_union)); size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint128_union));
connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l] (boost::system::error_code const & ec, size_t size_a) {
// An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect, // An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect,
// we simply get a size of 0. // we simply get a size of 0.
if (size_a == size_l) if (size_a == size_l)
@ -494,7 +494,7 @@ void nano::bulk_pull_server::send_next ()
{ {
connection->node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block->hash ().to_string ())); connection->node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block->hash ().to_string ()));
} }
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->sent_action (ec, size_a); this_l->sent_action (ec, size_a);
}); });
} }
@ -598,7 +598,7 @@ void nano::bulk_pull_server::send_finished ()
{ {
connection->node->logger.try_log ("Bulk sending finished"); connection->node->logger.try_log ("Bulk sending finished");
} }
connection->socket->async_write (send_buffer, [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->no_block_sent (ec, size_a); this_l->no_block_sent (ec, size_a);
}); });
} }
@ -620,8 +620,8 @@ void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec
} }
nano::bulk_pull_server::bulk_pull_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull> request_a) : nano::bulk_pull_server::bulk_pull_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull> request_a) :
connection (connection_a), connection (connection_a),
request (std::move (request_a)) request (std::move (request_a))
{ {
set_current_end (); set_current_end ();
} }
@ -700,7 +700,7 @@ void nano::bulk_pull_account_server::send_frontier ()
// Send the buffer to the requestor // Send the buffer to the requestor
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->sent_action (ec, size_a); this_l->sent_action (ec, size_a);
}); });
} }
@ -756,7 +756,7 @@ void nano::bulk_pull_account_server::send_next_block ()
} }
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->sent_action (ec, size_a); this_l->sent_action (ec, size_a);
}); });
} }
@ -903,7 +903,7 @@ void nano::bulk_pull_account_server::send_finished ()
connection->node->logger.try_log ("Bulk sending for an account finished"); connection->node->logger.try_log ("Bulk sending for an account finished");
} }
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->complete (ec, size_a); this_l->complete (ec, size_a);
}); });
} }
@ -940,9 +940,9 @@ void nano::bulk_pull_account_server::complete (boost::system::error_code const &
} }
nano::bulk_pull_account_server::bulk_pull_account_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull_account> request_a) : nano::bulk_pull_account_server::bulk_pull_account_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull_account> request_a) :
connection (connection_a), connection (connection_a),
request (std::move (request_a)), request (std::move (request_a)),
current_key (0, 0) current_key (0, 0)
{ {
/* /*
* Setup the streaming response for the first call to "send_frontier" and "send_next_block" * Setup the streaming response for the first call to "send_frontier" and "send_next_block"

28
nano/node/bootstrap/bootstrap_bulk_push.cpp
View file

@ -6,8 +6,8 @@
#include <boost/format.hpp> #include <boost/format.hpp>
nano::bulk_push_client::bulk_push_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) : nano::bulk_push_client::bulk_push_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) :
connection (connection_a), connection (connection_a),
attempt (attempt_a) attempt (attempt_a)
{ {
} }
@ -20,7 +20,7 @@ void nano::bulk_push_client::start ()
nano::bulk_push message; nano::bulk_push message;
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send ( connection->channel->send (
message, [this_l](boost::system::error_code const & ec, size_t size_a) { message, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->push (); this_l->push ();
@ -77,7 +77,7 @@ void nano::bulk_push_client::send_finished ()
{ {
nano::shared_const_buffer buffer (static_cast<uint8_t> (nano::block_type::not_a_block)); nano::shared_const_buffer buffer (static_cast<uint8_t> (nano::block_type::not_a_block));
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send_buffer (buffer, [this_l](boost::system::error_code const & ec, size_t size_a) { connection->channel->send_buffer (buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) {
try try
{ {
this_l->promise.set_value (false); this_l->promise.set_value (false);
@ -96,7 +96,7 @@ void nano::bulk_push_client::push_block (nano::block const & block_a)
nano::serialize_block (stream, block_a); nano::serialize_block (stream, block_a);
} }
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->push (); this_l->push ();
@ -112,8 +112,8 @@ void nano::bulk_push_client::push_block (nano::block const & block_a)
} }
nano::bulk_push_server::bulk_push_server (std::shared_ptr<nano::bootstrap_server> const & connection_a) : nano::bulk_push_server::bulk_push_server (std::shared_ptr<nano::bootstrap_server> const & connection_a) :
receive_buffer (std::make_shared<std::vector<uint8_t>> ()), receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
connection (connection_a) connection (connection_a)
{ {
receive_buffer->resize (256); receive_buffer->resize (256);
} }
@ -127,7 +127,7 @@ void nano::bulk_push_server::throttled_receive ()
else else
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l]() { connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l] () {
if (!this_l->connection->stopped) if (!this_l->connection->stopped)
{ {
this_l->throttled_receive (); this_l->throttled_receive ();
@ -148,7 +148,7 @@ void nano::bulk_push_server::receive ()
else else
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->socket->async_read (receive_buffer, 1, [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->received_type (); this_l->received_type ();
@ -173,7 +173,7 @@ void nano::bulk_push_server::received_type ()
case nano::block_type::send: case nano::block_type::send:
{ {
connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::send, nano::stat::dir::in); connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::send, nano::stat::dir::in);
connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
@ -181,7 +181,7 @@ void nano::bulk_push_server::received_type ()
case nano::block_type::receive: case nano::block_type::receive:
{ {
connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::receive, nano::stat::dir::in); connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::receive, nano::stat::dir::in);
connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
@ -189,7 +189,7 @@ void nano::bulk_push_server::received_type ()
case nano::block_type::open: case nano::block_type::open:
{ {
connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::open, nano::stat::dir::in); connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::open, nano::stat::dir::in);
connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
@ -197,7 +197,7 @@ void nano::bulk_push_server::received_type ()
case nano::block_type::change: case nano::block_type::change:
{ {
connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::change, nano::stat::dir::in); connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::change, nano::stat::dir::in);
connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;
@ -205,7 +205,7 @@ void nano::bulk_push_server::received_type ()
case nano::block_type::state: case nano::block_type::state:
{ {
connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::state_block, nano::stat::dir::in); connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::state_block, nano::stat::dir::in);
connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
this_l->received_block (ec, size_a, type); this_l->received_block (ec, size_a, type);
}); });
break; break;

22
nano/node/bootstrap/bootstrap_connections.cpp
View file

@ -14,12 +14,12 @@ constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections;
constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor; constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor;
nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::bootstrap_connections> const & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a) : nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::bootstrap_connections> const & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a) :
node (node_a), node (node_a),
connections (connections_a), connections (connections_a),
channel (channel_a), channel (channel_a),
socket (socket_a), socket (socket_a),
receive_buffer (std::make_shared<std::vector<uint8_t>> ()), receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
start_time_m (std::chrono::steady_clock::now ()) start_time_m (std::chrono::steady_clock::now ())
{ {
++connections->connections_count; ++connections->connections_count;
receive_buffer->resize (256); receive_buffer->resize (256);
@ -60,14 +60,14 @@ void nano::bootstrap_client::stop (bool force)
} }
nano::bootstrap_connections::bootstrap_connections (nano::node & node_a) : nano::bootstrap_connections::bootstrap_connections (nano::node & node_a) :
node (node_a) node (node_a)
{ {
} }
std::shared_ptr<nano::bootstrap_client> nano::bootstrap_connections::connection (std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, bool use_front_connection) std::shared_ptr<nano::bootstrap_client> nano::bootstrap_connections::connection (std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, bool use_front_connection)
{ {
nano::unique_lock<nano::mutex> lock (mutex); nano::unique_lock<nano::mutex> lock (mutex);
condition.wait (lock, [& stopped = stopped, &idle = idle, &new_connections_empty = new_connections_empty] { return stopped || !idle.empty () || new_connections_empty; }); condition.wait (lock, [&stopped = stopped, &idle = idle, &new_connections_empty = new_connections_empty] { return stopped || !idle.empty () || new_connections_empty; });
std::shared_ptr<nano::bootstrap_client> result; std::shared_ptr<nano::bootstrap_client> result;
if (!stopped && !idle.empty ()) if (!stopped && !idle.empty ())
{ {
@ -147,7 +147,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end
auto socket (std::make_shared<nano::socket> (node)); auto socket (std::make_shared<nano::socket> (node));
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
socket->async_connect (endpoint_a, socket->async_connect (endpoint_a,
[this_l, socket, endpoint_a, push_front](boost::system::error_code const & ec) { [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) {
if (!ec) if (!ec)
{ {
if (this_l->node.config.logging.bulk_pull_logging ()) if (this_l->node.config.logging.bulk_pull_logging ())
@ -304,7 +304,7 @@ void nano::bootstrap_connections::populate_connections (bool repeat)
if (!stopped && repeat) if (!stopped && repeat)
{ {
std::weak_ptr<nano::bootstrap_connections> this_w (shared_from_this ()); std::weak_ptr<nano::bootstrap_connections> this_w (shared_from_this ());
node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_w]() { node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
this_l->populate_connections (); this_l->populate_connections ();
@ -358,7 +358,7 @@ void nano::bootstrap_connections::request_pull (nano::unique_lock<nano::mutex> &
{ {
// The bulk_pull_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference // The bulk_pull_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference
// Dispatch request in an external thread in case it needs to be destroyed // Dispatch request in an external thread in case it needs to be destroyed
node.background ([connection_l, attempt_l, pull]() { node.background ([connection_l, attempt_l, pull] () {
auto client (std::make_shared<nano::bulk_pull_client> (connection_l, attempt_l, pull)); auto client (std::make_shared<nano::bulk_pull_client> (connection_l, attempt_l, pull));
client->request (); client->request ();
}); });

26
nano/node/bootstrap/bootstrap_frontier.cpp
View file

@ -24,7 +24,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint
next (); // Load accounts from disk next (); // Load accounts from disk
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send ( connection->channel->send (
request, [this_l](boost::system::error_code const & ec, size_t size_a) { request, [this_l] (boost::system::error_code const & ec, size_t size_a) {
if (!ec) if (!ec)
{ {
this_l->receive_frontier (); this_l->receive_frontier ();
@ -41,17 +41,17 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint
} }
nano::frontier_req_client::frontier_req_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) : nano::frontier_req_client::frontier_req_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) :
connection (connection_a), connection (connection_a),
attempt (attempt_a), attempt (attempt_a),
count (0), count (0),
bulk_push_cost (0) bulk_push_cost (0)
{ {
} }
void nano::frontier_req_client::receive_frontier () void nano::frontier_req_client::receive_frontier ()
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->socket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l] (boost::system::error_code const & ec, size_t size_a) {
// An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect, // An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect,
// we simply get a size of 0. // we simply get a size of 0.
if (size_a == nano::frontier_req_client::size_frontier) if (size_a == nano::frontier_req_client::size_frontier)
@ -234,11 +234,11 @@ void nano::frontier_req_client::next ()
} }
nano::frontier_req_server::frontier_req_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::frontier_req> request_a) : nano::frontier_req_server::frontier_req_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::frontier_req> request_a) :
connection (connection_a), connection (connection_a),
current (request_a->start.number () - 1), current (request_a->start.number () - 1),
frontier (0), frontier (0),
request (std::move (request_a)), request (std::move (request_a)),
count (0) count (0)
{ {
next (); next ();
} }
@ -261,7 +261,7 @@ void nano::frontier_req_server::send_next ()
connection->node->logger.try_log (boost::str (boost::format ("Sending frontier for %1% %2%") % current.to_account () % frontier.to_string ())); connection->node->logger.try_log (boost::str (boost::format ("Sending frontier for %1% %2%") % current.to_account () % frontier.to_string ()));
} }
next (); next ();
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->sent_action (ec, size_a); this_l->sent_action (ec, size_a);
}); });
} }
@ -285,7 +285,7 @@ void nano::frontier_req_server::send_finished ()
{ {
connection->node->logger.try_log ("Frontier sending finished"); connection->node->logger.try_log ("Frontier sending finished");
} }
connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
this_l->no_block_sent (ec, size_a); this_l->no_block_sent (ec, size_a);
}); });
} }

8
nano/node/bootstrap/bootstrap_lazy.cpp
View file

@ -14,7 +14,7 @@ constexpr double nano::bootstrap_limits::lazy_batch_pull_count_resize_ratio;
constexpr size_t nano::bootstrap_limits::lazy_blocks_restart_limit; constexpr size_t nano::bootstrap_limits::lazy_blocks_restart_limit;
nano::bootstrap_attempt_lazy::bootstrap_attempt_lazy (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string const & id_a) : nano::bootstrap_attempt_lazy::bootstrap_attempt_lazy (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string const & id_a) :
nano::bootstrap_attempt (node_a, nano::bootstrap_mode::lazy, incremental_id_a, id_a) nano::bootstrap_attempt (node_a, nano::bootstrap_mode::lazy, incremental_id_a, id_a)
{ {
node->bootstrap_initiator.notify_listeners (true); node->bootstrap_initiator.notify_listeners (true);
} }
@ -188,7 +188,7 @@ void nano::bootstrap_attempt_lazy::run ()
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
while (still_pulling () && !lazy_has_expired ()) while (still_pulling () && !lazy_has_expired ())
{ {
condition.wait (lock, [& stopped = stopped, &pulling = pulling, &lazy_pulls = lazy_pulls, this_l] { return stopped || pulling == 0 || (pulling < nano::bootstrap_limits::bootstrap_connection_scale_target_blocks && !lazy_pulls.empty ()) || this_l->lazy_has_expired (); }); condition.wait (lock, [&stopped = stopped, &pulling = pulling, &lazy_pulls = lazy_pulls, this_l] { return stopped || pulling == 0 || (pulling < nano::bootstrap_limits::bootstrap_connection_scale_target_blocks && !lazy_pulls.empty ()) || this_l->lazy_has_expired (); });
++iterations; ++iterations;
// Flushing lazy pulls // Flushing lazy pulls
lazy_pull_flush (lock); lazy_pull_flush (lock);
@ -462,7 +462,7 @@ void nano::bootstrap_attempt_lazy::get_information (boost::property_tree::ptree
} }
nano::bootstrap_attempt_wallet::bootstrap_attempt_wallet (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string id_a) : nano::bootstrap_attempt_wallet::bootstrap_attempt_wallet (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string id_a) :
nano::bootstrap_attempt (node_a, nano::bootstrap_mode::wallet_lazy, incremental_id_a, id_a) nano::bootstrap_attempt (node_a, nano::bootstrap_mode::wallet_lazy, incremental_id_a, id_a)
{ {
node->bootstrap_initiator.notify_listeners (true); node->bootstrap_initiator.notify_listeners (true);
} }
@ -485,7 +485,7 @@ void nano::bootstrap_attempt_wallet::request_pending (nano::unique_lock<nano::mu
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
// The bulk_pull_account_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference // The bulk_pull_account_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference
// Dispatch request in an external thread in case it needs to be destroyed // Dispatch request in an external thread in case it needs to be destroyed
node->background ([connection_l, this_l, account]() { node->background ([connection_l, this_l, account] () {
auto client (std::make_shared<nano::bulk_pull_account_client> (connection_l, this_l, account)); auto client (std::make_shared<nano::bulk_pull_account_client> (connection_l, this_l, account));
client->request (); client->request ();
}); });

6
nano/node/bootstrap/bootstrap_legacy.cpp
View file

@ -6,9 +6,9 @@
#include <boost/format.hpp> #include <boost/format.hpp>
nano::bootstrap_attempt_legacy::bootstrap_attempt_legacy (std::shared_ptr<nano::node> const & node_a, uint64_t const incremental_id_a, std::string const & id_a, uint32_t const frontiers_age_a, nano::account const & start_account_a) : nano::bootstrap_attempt_legacy::bootstrap_attempt_legacy (std::shared_ptr<nano::node> const & node_a, uint64_t const incremental_id_a, std::string const & id_a, uint32_t const frontiers_age_a, nano::account const & start_account_a) :
nano::bootstrap_attempt (node_a, nano::bootstrap_mode::legacy, incremental_id_a, id_a), nano::bootstrap_attempt (node_a, nano::bootstrap_mode::legacy, incremental_id_a, id_a),
frontiers_age (frontiers_age_a), frontiers_age (frontiers_age_a),
start_account (start_account_a) start_account (start_account_a)
{ {
node->bootstrap_initiator.notify_listeners (true); node->bootstrap_initiator.notify_listeners (true);
} }

42
nano/node/bootstrap/bootstrap_server.cpp
View file

@ -8,8 +8,8 @@
#include <boost/variant/get.hpp> #include <boost/variant/get.hpp>
nano::bootstrap_listener::bootstrap_listener (uint16_t port_a, nano::node & node_a) : nano::bootstrap_listener::bootstrap_listener (uint16_t port_a, nano::node & node_a) :
node (node_a), node (node_a),
port (port_a) port (port_a)
{ {
} }
@ -26,7 +26,7 @@ void nano::bootstrap_listener::start ()
throw std::runtime_error (ec.message ()); throw std::runtime_error (ec.message ());
} }
debug_assert (node.network.endpoint ().port () == listening_socket->listening_port ()); debug_assert (node.network.endpoint ().port () == listening_socket->listening_port ());
listening_socket->on_connection ([this](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { listening_socket->on_connection ([this] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
bool keep_accepting = true; bool keep_accepting = true;
if (ec_a) if (ec_a)
{ {
@ -104,9 +104,9 @@ std::unique_ptr<nano::container_info_component> nano::collect_container_info (bo
} }
nano::bootstrap_server::bootstrap_server (std::shared_ptr<nano::socket> const & socket_a, std::shared_ptr<nano::node> const & node_a) : nano::bootstrap_server::bootstrap_server (std::shared_ptr<nano::socket> const & socket_a, std::shared_ptr<nano::node> const & node_a) :
receive_buffer (std::make_shared<std::vector<uint8_t>> ()), receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
socket (socket_a), socket (socket_a),
node (node_a) node (node_a)
{ {
receive_buffer->resize (1024); receive_buffer->resize (1024);
} }
@ -153,7 +153,7 @@ void nano::bootstrap_server::receive ()
// Increase timeout to receive TCP header (idle server socket) // Increase timeout to receive TCP header (idle server socket)
socket->set_timeout (node->network_params.node.idle_timeout); socket->set_timeout (node->network_params.node.idle_timeout);
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
socket->async_read (receive_buffer, 8, [this_l](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, 8, [this_l] (boost::system::error_code const & ec, size_t size_a) {
// Set remote_endpoint // Set remote_endpoint
if (this_l->remote_endpoint.port () == 0) if (this_l->remote_endpoint.port () == 0)
{ {
@ -182,7 +182,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
case nano::message_type::bulk_pull: case nano::message_type::bulk_pull:
{ {
node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull, nano::stat::dir::in); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull, nano::stat::dir::in);
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_bulk_pull_action (ec, size_a, header); this_l->receive_bulk_pull_action (ec, size_a, header);
}); });
break; break;
@ -190,7 +190,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
case nano::message_type::bulk_pull_account: case nano::message_type::bulk_pull_account:
{ {
node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_account, nano::stat::dir::in); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_account, nano::stat::dir::in);
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_bulk_pull_account_action (ec, size_a, header); this_l->receive_bulk_pull_account_action (ec, size_a, header);
}); });
break; break;
@ -198,7 +198,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
case nano::message_type::frontier_req: case nano::message_type::frontier_req:
{ {
node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_req, nano::stat::dir::in); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_req, nano::stat::dir::in);
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_frontier_req_action (ec, size_a, header); this_l->receive_frontier_req_action (ec, size_a, header);
}); });
break; break;
@ -214,35 +214,35 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
} }
case nano::message_type::keepalive: case nano::message_type::keepalive:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_keepalive_action (ec, size_a, header); this_l->receive_keepalive_action (ec, size_a, header);
}); });
break; break;
} }
case nano::message_type::publish: case nano::message_type::publish:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_publish_action (ec, size_a, header); this_l->receive_publish_action (ec, size_a, header);
}); });
break; break;
} }
case nano::message_type::confirm_ack: case nano::message_type::confirm_ack:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_confirm_ack_action (ec, size_a, header); this_l->receive_confirm_ack_action (ec, size_a, header);
}); });
break; break;
} }
case nano::message_type::confirm_req: case nano::message_type::confirm_req:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_confirm_req_action (ec, size_a, header); this_l->receive_confirm_req_action (ec, size_a, header);
}); });
break; break;
} }
case nano::message_type::node_id_handshake: case nano::message_type::node_id_handshake:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_node_id_handshake_action (ec, size_a, header); this_l->receive_node_id_handshake_action (ec, size_a, header);
}); });
break; break;
@ -269,7 +269,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
} }
case nano::message_type::telemetry_ack: case nano::message_type::telemetry_ack:
{ {
socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) { socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
this_l->receive_telemetry_ack_action (ec, size_a, header); this_l->receive_telemetry_ack_action (ec, size_a, header);
}); });
break; break;
@ -567,7 +567,7 @@ void nano::bootstrap_server::finish_request ()
else else
{ {
std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ()); std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w]() { node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
this_l->timeout (); this_l->timeout ();
@ -579,7 +579,7 @@ void nano::bootstrap_server::finish_request ()
void nano::bootstrap_server::finish_request_async () void nano::bootstrap_server::finish_request_async ()
{ {
std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ()); std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
node->background ([this_w]() { node->background ([this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
this_l->finish_request (); this_l->finish_request ();
@ -617,7 +617,7 @@ class request_response_visitor : public nano::message_visitor
{ {
public: public:
explicit request_response_visitor (std::shared_ptr<nano::bootstrap_server> const & connection_a) : explicit request_response_visitor (std::shared_ptr<nano::bootstrap_server> const & connection_a) :
connection (connection_a) connection (connection_a)
{ {
} }
void keepalive (nano::keepalive const & message_a) override void keepalive (nano::keepalive const & message_a) override
@ -677,7 +677,7 @@ public:
auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint))); auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint)));
nano::node_id_handshake response_message (cookie, response); nano::node_id_handshake response_message (cookie, response);
auto shared_const_buffer = response_message.to_shared_const_buffer (); auto shared_const_buffer = response_message.to_shared_const_buffer ();
connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)](boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)] (boost::system::error_code const & ec, size_t size_a) {
if (auto connection_l = connection.lock ()) if (auto connection_l = connection.lock ())
{ {
if (ec) if (ec)
@ -748,7 +748,7 @@ void nano::bootstrap_server::run_next (nano::unique_lock<nano::mutex> & lock_a)
if (timeout_check) if (timeout_check)
{ {
std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ()); std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w]() { node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
this_l->timeout (); this_l->timeout ();

18
nano/node/cli.cpp
View file

@ -675,11 +675,11 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
if (valid_type) if (valid_type)
{ {
std::cout << "# This is an example configuration file for Nano. Visit https://docs.nano.org/running-a-node/configuration/ for more information.\n#\n" std::cout << "# This is an example configuration file for Nano. Visit https://docs.nano.org/running-a-node/configuration/ for more information.\n#\n"
<< "# Fields may need to be defined in the context of a [category] above them.\n" << "# Fields may need to be defined in the context of a [category] above them.\n"
<< "# The desired configuration changes should be placed in config-" << type << ".toml in the node data path.\n" << "# The desired configuration changes should be placed in config-" << type << ".toml in the node data path.\n"
<< "# To change a value from its default, uncomment (erasing #) the corresponding field.\n" << "# To change a value from its default, uncomment (erasing #) the corresponding field.\n"
<< "# It is not recommended to uncomment every field, as the default value for important fields may change in the future. Only change what you need.\n" << "# It is not recommended to uncomment every field, as the default value for important fields may change in the future. Only change what you need.\n"
<< "# Additional information for notable configuration options is available in https://docs.nano.org/running-a-node/configuration/#notable-configuration-options\n"; << "# Additional information for notable configuration options is available in https://docs.nano.org/running-a-node/configuration/#notable-configuration-options\n";
if (vm.count ("use_defaults")) if (vm.count ("use_defaults"))
{ {
@ -732,8 +732,8 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
{ {
nano::keypair pair; nano::keypair pair;
std::cout << "Private: " << pair.prv.to_string () << std::endl std::cout << "Private: " << pair.prv.to_string () << std::endl
<< "Public: " << pair.pub.to_string () << std::endl << "Public: " << pair.pub.to_string () << std::endl
<< "Account: " << pair.pub.to_account () << std::endl; << "Account: " << pair.pub.to_account () << std::endl;
} }
else if (vm.count ("key_expand")) else if (vm.count ("key_expand"))
{ {
@ -743,8 +743,8 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
prv.decode_hex (vm["key"].as<std::string> ()); prv.decode_hex (vm["key"].as<std::string> ());
nano::public_key pub (nano::pub_key (prv)); nano::public_key pub (nano::pub_key (prv));
std::cout << "Private: " << prv.to_string () << std::endl std::cout << "Private: " << prv.to_string () << std::endl
<< "Public: " << pub.to_string () << std::endl << "Public: " << pub.to_string () << std::endl
<< "Account: " << pub.to_account () << std::endl; << "Account: " << pub.to_account () << std::endl;
} }
else else
{ {

98
nano/node/common.cpp
View file

@ -50,9 +50,9 @@ uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint1
} }
nano::message_header::message_header (nano::message_type type_a) : nano::message_header::message_header (nano::message_type type_a) :
version_max (get_protocol_constants ().protocol_version), version_max (get_protocol_constants ().protocol_version),
version_using (get_protocol_constants ().protocol_version), version_using (get_protocol_constants ().protocol_version),
type (type_a) type (type_a)
{ {
} }
@ -111,12 +111,12 @@ uint8_t nano::message_header::version_min () const
} }
nano::message::message (nano::message_type type_a) : nano::message::message (nano::message_type type_a) :
header (type_a) header (type_a)
{ {
} }
nano::message::message (nano::message_header const & header_a) : nano::message::message (nano::message_header const & header_a) :
header (header_a) header (header_a)
{ {
} }
@ -336,12 +336,12 @@ std::string nano::message_parser::status_string ()
} }
nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a) : nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a) :
publish_filter (publish_filter_a), publish_filter (publish_filter_a),
block_uniquer (block_uniquer_a), block_uniquer (block_uniquer_a),
vote_uniquer (vote_uniquer_a), vote_uniquer (vote_uniquer_a),
visitor (visitor_a), visitor (visitor_a),
pool (pool_a), pool (pool_a),
status (parse_status::success) status (parse_status::success)
{ {
} }
@ -558,7 +558,7 @@ bool nano::message_parser::at_end (nano::stream & stream_a)
} }
nano::keepalive::keepalive () : nano::keepalive::keepalive () :
message (nano::message_type::keepalive) message (nano::message_type::keepalive)
{ {
nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0); nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0);
for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i)
@ -568,7 +568,7 @@ message (nano::message_type::keepalive)
} }
nano::keepalive::keepalive (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : nano::keepalive::keepalive (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -619,8 +619,8 @@ bool nano::keepalive::operator== (nano::keepalive const & other_a) const
} }
nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::uint128_t const & digest_a, nano::block_uniquer * uniquer_a) : nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::uint128_t const & digest_a, nano::block_uniquer * uniquer_a) :
message (header_a), message (header_a),
digest (digest_a) digest (digest_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -629,8 +629,8 @@ digest (digest_a)
} }
nano::publish::publish (std::shared_ptr<nano::block> const & block_a) : nano::publish::publish (std::shared_ptr<nano::block> const & block_a) :
message (nano::message_type::publish), message (nano::message_type::publish),
block (block_a) block (block_a)
{ {
header.block_type_set (block->type ()); header.block_type_set (block->type ());
} }
@ -661,7 +661,7 @@ bool nano::publish::operator== (nano::publish const & other_a) const
} }
nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::block_uniquer * uniquer_a) : nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::block_uniquer * uniquer_a) :
message (header_a) message (header_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -670,15 +670,15 @@ message (header_a)
} }
nano::confirm_req::confirm_req (std::shared_ptr<nano::block> const & block_a) : nano::confirm_req::confirm_req (std::shared_ptr<nano::block> const & block_a) :
message (nano::message_type::confirm_req), message (nano::message_type::confirm_req),
block (block_a) block (block_a)
{ {
header.block_type_set (block->type ()); header.block_type_set (block->type ());
} }
nano::confirm_req::confirm_req (std::vector<std::pair<nano::block_hash, nano::root>> const & roots_hashes_a) : nano::confirm_req::confirm_req (std::vector<std::pair<nano::block_hash, nano::root>> const & roots_hashes_a) :
message (nano::message_type::confirm_req), message (nano::message_type::confirm_req),
roots_hashes (roots_hashes_a) roots_hashes (roots_hashes_a)
{ {
// not_a_block (1) block type for hashes + roots request // not_a_block (1) block type for hashes + roots request
header.block_type_set (nano::block_type::not_a_block); header.block_type_set (nano::block_type::not_a_block);
@ -687,8 +687,8 @@ roots_hashes (roots_hashes_a)
} }
nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) : nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) :
message (nano::message_type::confirm_req), message (nano::message_type::confirm_req),
roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a))) roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a)))
{ {
debug_assert (!roots_hashes.empty ()); debug_assert (!roots_hashes.empty ());
// not_a_block (1) block type for hashes + roots request // not_a_block (1) block type for hashes + roots request
@ -801,8 +801,8 @@ size_t nano::confirm_req::size (nano::block_type type_a, size_t count)
} }
nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::vote_uniquer * uniquer_a) : nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::vote_uniquer * uniquer_a) :
message (header_a), message (header_a),
vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ())) vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ()))
{ {
if (!error_a && uniquer_a) if (!error_a && uniquer_a)
{ {
@ -811,8 +811,8 @@ vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ()))
} }
nano::confirm_ack::confirm_ack (std::shared_ptr<nano::vote> const & vote_a) : nano::confirm_ack::confirm_ack (std::shared_ptr<nano::vote> const & vote_a) :
message (nano::message_type::confirm_ack), message (nano::message_type::confirm_ack),
vote (vote_a) vote (vote_a)
{ {
debug_assert (!vote_a->blocks.empty ()); debug_assert (!vote_a->blocks.empty ());
auto & first_vote_block (vote_a->blocks[0]); auto & first_vote_block (vote_a->blocks[0]);
@ -861,12 +861,12 @@ size_t nano::confirm_ack::size (nano::block_type type_a, size_t count)
} }
nano::frontier_req::frontier_req () : nano::frontier_req::frontier_req () :
message (nano::message_type::frontier_req) message (nano::message_type::frontier_req)
{ {
} }
nano::frontier_req::frontier_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : nano::frontier_req::frontier_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -911,12 +911,12 @@ bool nano::frontier_req::operator== (nano::frontier_req const & other_a) const
} }
nano::bulk_pull::bulk_pull () : nano::bulk_pull::bulk_pull () :
message (nano::message_type::bulk_pull) message (nano::message_type::bulk_pull)
{ {
} }
nano::bulk_pull::bulk_pull (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : nano::bulk_pull::bulk_pull (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1007,12 +1007,12 @@ void nano::bulk_pull::set_count_present (bool value_a)
} }
nano::bulk_pull_account::bulk_pull_account () : nano::bulk_pull_account::bulk_pull_account () :
message (nano::message_type::bulk_pull_account) message (nano::message_type::bulk_pull_account)
{ {
} }
nano::bulk_pull_account::bulk_pull_account (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : nano::bulk_pull_account::bulk_pull_account (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
if (!error_a) if (!error_a)
{ {
@ -1052,12 +1052,12 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a)
} }
nano::bulk_push::bulk_push () : nano::bulk_push::bulk_push () :
message (nano::message_type::bulk_push) message (nano::message_type::bulk_push)
{ {
} }
nano::bulk_push::bulk_push (nano::message_header const & header_a) : nano::bulk_push::bulk_push (nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
} }
@ -1078,12 +1078,12 @@ void nano::bulk_push::visit (nano::message_visitor & visitor_a) const
} }
nano::telemetry_req::telemetry_req () : nano::telemetry_req::telemetry_req () :
message (nano::message_type::telemetry_req) message (nano::message_type::telemetry_req)
{ {
} }
nano::telemetry_req::telemetry_req (nano::message_header const & header_a) : nano::telemetry_req::telemetry_req (nano::message_header const & header_a) :
message (header_a) message (header_a)
{ {
} }
@ -1104,12 +1104,12 @@ void nano::telemetry_req::visit (nano::message_visitor & visitor_a) const
} }
nano::telemetry_ack::telemetry_ack () : nano::telemetry_ack::telemetry_ack () :
message (nano::message_type::telemetry_ack) message (nano::message_type::telemetry_ack)
{ {
} }
nano::telemetry_ack::telemetry_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & message_header) : nano::telemetry_ack::telemetry_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & message_header) :
message (message_header) message (message_header)
{ {
if (!error_a) if (!error_a)
{ {
@ -1118,8 +1118,8 @@ message (message_header)
} }
nano::telemetry_ack::telemetry_ack (nano::telemetry_data const & telemetry_data_a) : nano::telemetry_ack::telemetry_ack (nano::telemetry_data const & telemetry_data_a) :
message (nano::message_type::telemetry_ack), message (nano::message_type::telemetry_ack),
data (telemetry_data_a) data (telemetry_data_a)
{ {
debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows
header.extensions &= ~message_header::telemetry_size_mask; header.extensions &= ~message_header::telemetry_size_mask;
@ -1357,17 +1357,17 @@ bool nano::telemetry_data::validate_signature () const
} }
nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
message (header_a), message (header_a),
query (boost::none), query (boost::none),
response (boost::none) response (boost::none)
{ {
error_a = deserialize (stream_a); error_a = deserialize (stream_a);
} }
nano::node_id_handshake::node_id_handshake (boost::optional<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> response) : nano::node_id_handshake::node_id_handshake (boost::optional<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> response) :
message (nano::message_type::node_id_handshake), message (nano::message_type::node_id_handshake),
query (query), query (query),
response (response) response (response)
{ {
if (query) if (query)
{ {
@ -1558,6 +1558,6 @@ std::chrono::seconds nano::telemetry_cache_cutoffs::network_to_time (network_con
} }
nano::node_singleton_memory_pool_purge_guard::node_singleton_memory_pool_purge_guard () : nano::node_singleton_memory_pool_purge_guard::node_singleton_memory_pool_purge_guard () :
cleanup_guard ({ nano::block_memory_pool_purge, nano::purge_shared_ptr_singleton_pool_memory<nano::vote>, nano::purge_shared_ptr_singleton_pool_memory<nano::election>, nano::purge_singleton_inactive_votes_cache_pool_memory }) cleanup_guard ({ nano::block_memory_pool_purge, nano::purge_shared_ptr_singleton_pool_memory<nano::vote>, nano::purge_shared_ptr_singleton_pool_memory<nano::election>, nano::purge_singleton_inactive_votes_cache_pool_memory })
{ {
} }

52
nano/node/confirmation_height_bounded.cpp
View file

@ -11,16 +11,16 @@
#include <numeric> #include <numeric>
nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) : nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) :
ledger (ledger_a), ledger (ledger_a),
write_database_queue (write_database_queue_a), write_database_queue (write_database_queue_a),
batch_separate_pending_min_time (batch_separate_pending_min_time_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a),
logging (logging_a), logging (logging_a),
logger (logger_a), logger (logger_a),
stopped (stopped_a), stopped (stopped_a),
batch_write_size (batch_write_size_a), batch_write_size (batch_write_size_a),
notify_observers_callback (notify_observers_callback_a), notify_observers_callback (notify_observers_callback_a),
notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a), notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
awaiting_processing_size_callback (awaiting_processing_size_callback_a) awaiting_processing_size_callback (awaiting_processing_size_callback_a)
{ {
} }
@ -561,34 +561,34 @@ void nano::confirmation_height_bounded::clear_process_vars ()
} }
nano::confirmation_height_bounded::receive_chain_details::receive_chain_details (nano::account const & account_a, uint64_t height_a, nano::block_hash const & hash_a, nano::block_hash const & top_level_a, boost::optional<nano::block_hash> next_a, uint64_t bottom_height_a, nano::block_hash const & bottom_most_a) : nano::confirmation_height_bounded::receive_chain_details::receive_chain_details (nano::account const & account_a, uint64_t height_a, nano::block_hash const & hash_a, nano::block_hash const & top_level_a, boost::optional<nano::block_hash> next_a, uint64_t bottom_height_a, nano::block_hash const & bottom_most_a) :
account (account_a), account (account_a),
height (height_a), height (height_a),
hash (hash_a), hash (hash_a),
top_level (top_level_a), top_level (top_level_a),
next (next_a), next (next_a),
bottom_height (bottom_height_a), bottom_height (bottom_height_a),
bottom_most (bottom_most_a) bottom_most (bottom_most_a)
{ {
} }
nano::confirmation_height_bounded::write_details::write_details (nano::account const & account_a, uint64_t bottom_height_a, nano::block_hash const & bottom_hash_a, uint64_t top_height_a, nano::block_hash const & top_hash_a) : nano::confirmation_height_bounded::write_details::write_details (nano::account const & account_a, uint64_t bottom_height_a, nano::block_hash const & bottom_hash_a, uint64_t top_height_a, nano::block_hash const & top_hash_a) :
account (account_a), account (account_a),
bottom_height (bottom_height_a), bottom_height (bottom_height_a),
bottom_hash (bottom_hash_a), bottom_hash (bottom_hash_a),
top_height (top_height_a), top_height (top_height_a),
top_hash (top_hash_a) top_hash (top_hash_a)
{ {
} }
nano::confirmation_height_bounded::receive_source_pair::receive_source_pair (confirmation_height_bounded::receive_chain_details const & receive_details_a, const block_hash & source_a) : nano::confirmation_height_bounded::receive_source_pair::receive_source_pair (confirmation_height_bounded::receive_chain_details const & receive_details_a, const block_hash & source_a) :
receive_details (receive_details_a), receive_details (receive_details_a),
source_hash (source_a) source_hash (source_a)
{ {
} }
nano::confirmation_height_bounded::confirmed_info::confirmed_info (uint64_t confirmed_height_a, nano::block_hash const & iterated_frontier_a) : nano::confirmation_height_bounded::confirmed_info::confirmed_info (uint64_t confirmed_height_a, nano::block_hash const & iterated_frontier_a) :
confirmed_height (confirmed_height_a), confirmed_height (confirmed_height_a),
iterated_frontier (iterated_frontier_a) iterated_frontier (iterated_frontier_a)
{ {
} }

20
nano/node/confirmation_height_processor.cpp
View file

@ -12,18 +12,18 @@
#include <numeric> #include <numeric>
nano::confirmation_height_processor::confirmation_height_processor (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, boost::latch & latch, confirmation_height_mode mode_a) : nano::confirmation_height_processor::confirmation_height_processor (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, boost::latch & latch, confirmation_height_mode mode_a) :
ledger (ledger_a), ledger (ledger_a),
write_database_queue (write_database_queue_a), write_database_queue (write_database_queue_a),
// clang-format off // clang-format off
unbounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }), unbounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }),
bounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }), bounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }),
// clang-format on // clang-format on
thread ([this, &latch, mode_a] () { thread ([this, &latch, mode_a] () {
nano::thread_role::set (nano::thread_role::name::confirmation_height_processing); nano::thread_role::set (nano::thread_role::name::confirmation_height_processing);
// Do not start running the processing thread until other threads have finished their operations // Do not start running the processing thread until other threads have finished their operations
latch.wait (); latch.wait ();
this->run (mode_a); this->run (mode_a);
}) })
{ {
} }

38
nano/node/confirmation_height_unbounded.cpp
View file

@ -9,16 +9,16 @@
#include <numeric> #include <numeric>
nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) : nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) :
ledger (ledger_a), ledger (ledger_a),
write_database_queue (write_database_queue_a), write_database_queue (write_database_queue_a),
batch_separate_pending_min_time (batch_separate_pending_min_time_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a),
logging (logging_a), logging (logging_a),
logger (logger_a), logger (logger_a),
stopped (stopped_a), stopped (stopped_a),
batch_write_size (batch_write_size_a), batch_write_size (batch_write_size_a),
notify_observers_callback (notify_observers_callback_a), notify_observers_callback (notify_observers_callback_a),
notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a), notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
awaiting_processing_size_callback (awaiting_processing_size_callback_a) awaiting_processing_size_callback (awaiting_processing_size_callback_a)
{ {
} }
@ -485,23 +485,23 @@ uint64_t nano::confirmation_height_unbounded::block_cache_size () const
} }
nano::confirmation_height_unbounded::conf_height_details::conf_height_details (nano::account const & account_a, nano::block_hash const & hash_a, uint64_t height_a, uint64_t num_blocks_confirmed_a, std::vector<nano::block_hash> const & block_callback_data_a) : nano::confirmation_height_unbounded::conf_height_details::conf_height_details (nano::account const & account_a, nano::block_hash const & hash_a, uint64_t height_a, uint64_t num_blocks_confirmed_a, std::vector<nano::block_hash> const & block_callback_data_a) :
account (account_a), account (account_a),
hash (hash_a), hash (hash_a),
height (height_a), height (height_a),
num_blocks_confirmed (num_blocks_confirmed_a), num_blocks_confirmed (num_blocks_confirmed_a),
block_callback_data (block_callback_data_a) block_callback_data (block_callback_data_a)
{ {
} }
nano::confirmation_height_unbounded::receive_source_pair::receive_source_pair (std::shared_ptr<conf_height_details> const & receive_details_a, const block_hash & source_a) : nano::confirmation_height_unbounded::receive_source_pair::receive_source_pair (std::shared_ptr<conf_height_details> const & receive_details_a, const block_hash & source_a) :
receive_details (receive_details_a), receive_details (receive_details_a),
source_hash (source_a) source_hash (source_a)
{ {
} }
nano::confirmation_height_unbounded::confirmed_iterated_pair::confirmed_iterated_pair (uint64_t confirmed_height_a, uint64_t iterated_height_a) : nano::confirmation_height_unbounded::confirmed_iterated_pair::confirmed_iterated_pair (uint64_t confirmed_height_a, uint64_t iterated_height_a) :
confirmed_height (confirmed_height_a), confirmed_height (confirmed_height_a),
iterated_height (iterated_height_a) iterated_height (iterated_height_a)
{ {
} }

10
nano/node/confirmation_solicitor.cpp
View file

@ -5,11 +5,11 @@
using namespace std::chrono_literals; using namespace std::chrono_literals;
nano::confirmation_solicitor::confirmation_solicitor (nano::network & network_a, nano::node_config const & config_a) : nano::confirmation_solicitor::confirmation_solicitor (nano::network & network_a, nano::node_config const & config_a) :
max_block_broadcasts (config_a.network_params.network.is_dev_network () ? 4 : 30), max_block_broadcasts (config_a.network_params.network.is_dev_network () ? 4 : 30),
max_election_requests (50), max_election_requests (50),
max_election_broadcasts (std::max<size_t> (network_a.fanout () / 2, 1)), max_election_broadcasts (std::max<size_t> (network_a.fanout () / 2, 1)),
network (network_a), network (network_a),
config (config_a) config (config_a)
{ {
} }

6
nano/node/daemonconfig.cpp
View file

@ -8,7 +8,7 @@
#include <vector> #include <vector>
nano::daemon_config::daemon_config (boost::filesystem::path const & data_path_a) : nano::daemon_config::daemon_config (boost::filesystem::path const & data_path_a) :
data_path (data_path_a) data_path (data_path_a)
{ {
} }
@ -144,8 +144,8 @@ nano::error nano::read_node_config_toml (boost::filesystem::path const & data_pa
if (boost::filesystem::exists (toml_config_path)) if (boost::filesystem::exists (toml_config_path))
{ {
error = "Both json and toml node configuration files exists. " error = "Both json and toml node configuration files exists. "
"Either remove the config.json file and restart, or remove " "Either remove the config.json file and restart, or remove "
"the config-node.toml file to start migration on next launch."; "the config-node.toml file to start migration on next launch.";
} }
else else
{ {

28
nano/node/distributed_work.cpp
View file

@ -21,13 +21,13 @@ std::shared_ptr<request_type> nano::distributed_work::peer_request::get_prepared
} }
nano::distributed_work::distributed_work (nano::node & node_a, nano::work_request const & request_a, std::chrono::seconds const & backoff_a) : nano::distributed_work::distributed_work (nano::node & node_a, nano::work_request const & request_a, std::chrono::seconds const & backoff_a) :
node (node_a), node (node_a),
node_w (node_a.shared ()), node_w (node_a.shared ()),
request (request_a), request (request_a),
backoff (backoff_a), backoff (backoff_a),
strand (node_a.io_ctx.get_executor ()), strand (node_a.io_ctx.get_executor ()),
need_resolve (request_a.peers), need_resolve (request_a.peers),
elapsed (nano::timer_state::started, "distributed work generation timer") elapsed (nano::timer_state::started, "distributed work generation timer")
{ {
debug_assert (!finished); debug_assert (!finished);
debug_assert (status == work_generation_status::ongoing); debug_assert (status == work_generation_status::ongoing);
@ -82,7 +82,7 @@ void nano::distributed_work::start ()
else else
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
node.network.resolver.async_resolve (boost::asio::ip::udp::resolver::query (peer.first, std::to_string (peer.second)), [peer, this_l, &extra = resolved_extra](boost::system::error_code const & ec, boost::asio::ip::udp::resolver::iterator i_a) { node.network.resolver.async_resolve (boost::asio::ip::udp::resolver::query (peer.first, std::to_string (peer.second)), [peer, this_l, &extra = resolved_extra] (boost::system::error_code const & ec, boost::asio::ip::udp::resolver::iterator i_a) {
if (!ec) if (!ec)
{ {
this_l->do_request (nano::tcp_endpoint (i_a->endpoint ().address (), i_a->endpoint ().port ())); this_l->do_request (nano::tcp_endpoint (i_a->endpoint ().address (), i_a->endpoint ().port ()));
@ -107,7 +107,7 @@ void nano::distributed_work::start_local ()
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
local_generation_started = true; local_generation_started = true;
node.work.generate (request.version, request.root, request.difficulty, [this_l](boost::optional<uint64_t> const & work_a) { node.work.generate (request.version, request.root, request.difficulty, [this_l] (boost::optional<uint64_t> const & work_a) {
if (work_a.is_initialized ()) if (work_a.is_initialized ())
{ {
this_l->set_once (*work_a); this_l->set_once (*work_a);
@ -134,7 +134,7 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a)
} }
connection->socket.async_connect (connection->endpoint, connection->socket.async_connect (connection->endpoint,
boost::asio::bind_executor (strand, boost::asio::bind_executor (strand,
[this_l, connection](boost::system::error_code const & ec) { [this_l, connection] (boost::system::error_code const & ec) {
if (!ec && !this_l->stopped) if (!ec && !this_l->stopped)
{ {
std::string request_string; std::string request_string;
@ -154,11 +154,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a)
auto peer_request (connection->get_prepared_json_request (request_string)); auto peer_request (connection->get_prepared_json_request (request_string));
boost::beast::http::async_write (connection->socket, *peer_request, boost::beast::http::async_write (connection->socket, *peer_request,
boost::asio::bind_executor (this_l->strand, boost::asio::bind_executor (this_l->strand,
[this_l, connection, peer_request](boost::system::error_code const & ec, size_t size_a) { [this_l, connection, peer_request] (boost::system::error_code const & ec, size_t size_a) {
if (!ec && !this_l->stopped) if (!ec && !this_l->stopped)
{ {
boost::beast::http::async_read (connection->socket, connection->buffer, connection->response, boost::beast::http::async_read (connection->socket, connection->buffer, connection->response,
boost::asio::bind_executor (this_l->strand, [this_l, connection](boost::system::error_code const & ec, size_t size_a) { boost::asio::bind_executor (this_l->strand, [this_l, connection] (boost::system::error_code const & ec, size_t size_a) {
if (!ec && !this_l->stopped) if (!ec && !this_l->stopped)
{ {
if (connection->response.result () == boost::beast::http::status::ok) if (connection->response.result () == boost::beast::http::status::ok)
@ -202,7 +202,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a)
auto cancelling_l (std::make_shared<peer_request> (node.io_ctx, endpoint_a)); auto cancelling_l (std::make_shared<peer_request> (node.io_ctx, endpoint_a));
cancelling_l->socket.async_connect (cancelling_l->endpoint, cancelling_l->socket.async_connect (cancelling_l->endpoint,
boost::asio::bind_executor (strand, boost::asio::bind_executor (strand,
[this_l, cancelling_l](boost::system::error_code const & ec) { [this_l, cancelling_l] (boost::system::error_code const & ec) {
if (!ec) if (!ec)
{ {
std::string request_string; std::string request_string;
@ -217,7 +217,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a)
auto peer_cancel (cancelling_l->get_prepared_json_request (request_string)); auto peer_cancel (cancelling_l->get_prepared_json_request (request_string));
boost::beast::http::async_write (cancelling_l->socket, *peer_cancel, boost::beast::http::async_write (cancelling_l->socket, *peer_cancel,
boost::asio::bind_executor (this_l->strand, boost::asio::bind_executor (this_l->strand,
[this_l, peer_cancel, cancelling_l](boost::system::error_code const & ec, size_t bytes_transferred) { [this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, size_t bytes_transferred) {
if (ec && ec != boost::system::errc::operation_canceled) if (ec && ec != boost::system::errc::operation_canceled)
{ {
this_l->node.logger.try_log (boost::str (boost::format ("Unable to send work_cancel to work_peer %1% %2%: %3% (%4%)") % cancelling_l->endpoint.address () % cancelling_l->endpoint.port () % ec.message () % ec.value ())); this_l->node.logger.try_log (boost::str (boost::format ("Unable to send work_cancel to work_peer %1% %2%: %3% (%4%)") % cancelling_l->endpoint.address () % cancelling_l->endpoint.port () % ec.message () % ec.value ()));

6
nano/node/distributed_work.hpp
View file

@ -33,7 +33,7 @@ struct work_request final
nano::root root; nano::root root;
uint64_t difficulty; uint64_t difficulty;
boost::optional<nano::account> const account; boost::optional<nano::account> const account;
std::function<void(boost::optional<uint64_t>)> callback; std::function<void (boost::optional<uint64_t>)> callback;
std::vector<std::pair<std::string, uint16_t>> const peers; std::vector<std::pair<std::string, uint16_t>> const peers;
}; };
@ -55,8 +55,8 @@ class distributed_work final : public std::enable_shared_from_this<nano::distrib
{ {
public: public:
peer_request (boost::asio::io_context & io_ctx_a, nano::tcp_endpoint const & endpoint_a) : peer_request (boost::asio::io_context & io_ctx_a, nano::tcp_endpoint const & endpoint_a) :
endpoint (endpoint_a), endpoint (endpoint_a),
socket (io_ctx_a) socket (io_ctx_a)
{ {
} }
std::shared_ptr<request_type> get_prepared_json_request (std::string const &) const; std::shared_ptr<request_type> get_prepared_json_request (std::string const &) const;

10
nano/node/distributed_work_factory.cpp
View file

@ -3,7 +3,7 @@
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
nano::distributed_work_factory::distributed_work_factory (nano::node & node_a) : nano::distributed_work_factory::distributed_work_factory (nano::node & node_a) :
node (node_a) node (node_a)
{ {
} }
@ -12,7 +12,7 @@ nano::distributed_work_factory::~distributed_work_factory ()
stop (); stop ();
} }
bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t>)> const & callback_a, boost::optional<nano::account> const & account_a) bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t>)> const & callback_a, boost::optional<nano::account> const & account_a)
{ {
return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a }); return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a });
} }
@ -41,7 +41,7 @@ void nano::distributed_work_factory::cancel (nano::root const & root_a)
{ {
nano::lock_guard<nano::mutex> guard_l (mutex); nano::lock_guard<nano::mutex> guard_l (mutex);
auto root_items_l = items.equal_range (root_a); auto root_items_l = items.equal_range (root_a);
std::for_each (root_items_l.first, root_items_l.second, [](auto item_l) { std::for_each (root_items_l.first, root_items_l.second, [] (auto item_l) {
if (auto distributed_l = item_l.second.lock ()) if (auto distributed_l = item_l.second.lock ())
{ {
// Send work_cancel to work peers and stop local work generation // Send work_cancel to work peers and stop local work generation
@ -55,7 +55,7 @@ void nano::distributed_work_factory::cleanup_finished ()
{ {
nano::lock_guard<nano::mutex> guard (mutex); nano::lock_guard<nano::mutex> guard (mutex);
// std::erase_if in c++20 // std::erase_if in c++20
auto erase_if = [](decltype (items) & container, auto pred) { auto erase_if = [] (decltype (items) & container, auto pred) {
for (auto it = container.begin (), end = container.end (); it != end;) for (auto it = container.begin (), end = container.end (); it != end;)
{ {
if (pred (*it)) if (pred (*it))
@ -68,7 +68,7 @@ void nano::distributed_work_factory::cleanup_finished ()
} }
} }
}; };
erase_if (items, [](decltype (items)::value_type item) { return item.second.expired (); }); erase_if (items, [] (decltype (items)::value_type item) { return item.second.expired (); });
} }
void nano::distributed_work_factory::stop () void nano::distributed_work_factory::stop ()

2
nano/node/distributed_work_factory.hpp
View file

@ -21,7 +21,7 @@ class distributed_work_factory final
public: public:
distributed_work_factory (nano::node &); distributed_work_factory (nano::node &);
~distributed_work_factory (); ~distributed_work_factory ();
bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void(boost::optional<uint64_t>)> const &, boost::optional<nano::account> const & = boost::none); bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void (boost::optional<uint64_t>)> const &, boost::optional<nano::account> const & = boost::none);
bool make (std::chrono::seconds const &, nano::work_request const &); bool make (std::chrono::seconds const &, nano::work_request const &);
void cancel (nano::root const &); void cancel (nano::root const &);
void cleanup_finished (); void cleanup_finished ();

28
nano/node/election.cpp
View file

@ -18,16 +18,16 @@ nano::election_vote_result::election_vote_result (bool replay_a, bool processed_
processed = processed_a; processed = processed_a;
} }
nano::election::election (nano::node & node_a, std::shared_ptr<nano::block> const & block_a, std::function<void(std::shared_ptr<nano::block> const &)> const & confirmation_action_a, std::function<void(nano::account const &)> const & live_vote_action_a, bool prioritized_a, nano::election_behavior election_behavior_a) : nano::election::election (nano::node & node_a, std::shared_ptr<nano::block> const & block_a, std::function<void (std::shared_ptr<nano::block> const &)> const & confirmation_action_a, std::function<void (nano::account const &)> const & live_vote_action_a, bool prioritized_a, nano::election_behavior election_behavior_a) :
confirmation_action (confirmation_action_a), confirmation_action (confirmation_action_a),
live_vote_action (live_vote_action_a), live_vote_action (live_vote_action_a),
prioritized_m (prioritized_a), prioritized_m (prioritized_a),
behavior (election_behavior_a), behavior (election_behavior_a),
node (node_a), node (node_a),
status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::ongoing }), status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::ongoing }),
height (block_a->sideband ().height), height (block_a->sideband ().height),
root (block_a->root ()), root (block_a->root ()),
qualified_root (block_a->qualified_root ()) qualified_root (block_a->qualified_root ())
{ {
last_votes.emplace (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () }); last_votes.emplace (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () });
last_blocks.emplace (block_a->hash (), block_a); last_blocks.emplace (block_a->hash (), block_a);
@ -52,7 +52,7 @@ void nano::election::confirm_once (nano::unique_lock<nano::mutex> & lock_a, nano
lock_a.unlock (); lock_a.unlock ();
node.active.add_recently_confirmed (status_l.winner->qualified_root (), status_l.winner->hash ()); node.active.add_recently_confirmed (status_l.winner->qualified_root (), status_l.winner->hash ());
node.process_confirmed (status_l); node.process_confirmed (status_l);
node.background ([node_l = node.shared (), status_l, confirmation_action_l = confirmation_action]() { node.background ([node_l = node.shared (), status_l, confirmation_action_l = confirmation_action] () {
if (confirmation_action_l) if (confirmation_action_l)
{ {
confirmation_action_l (status_l.winner); confirmation_action_l (status_l.winner);
@ -551,7 +551,7 @@ bool nano::election::replace_by_weight (nano::unique_lock<nano::mutex> & lock_a,
std::copy (last_tally.begin (), last_tally.end (), std::back_inserter (sorted)); std::copy (last_tally.begin (), last_tally.end (), std::back_inserter (sorted));
lock_a.unlock (); lock_a.unlock ();
// Sort in ascending order // Sort in ascending order
std::sort (sorted.begin (), sorted.end (), [](auto const & left, auto const & right) { return left.second < right.second; }); std::sort (sorted.begin (), sorted.end (), [] (auto const & left, auto const & right) { return left.second < right.second; });
// Replace if lowest tally is below inactive cache new block weight // Replace if lowest tally is below inactive cache new block weight
auto inactive_existing (node.active.find_inactive_votes_cache (hash_a)); auto inactive_existing (node.active.find_inactive_votes_cache (hash_a));
auto inactive_tally (inactive_existing.status.tally); auto inactive_tally (inactive_existing.status.tally);
@ -560,7 +560,7 @@ bool nano::election::replace_by_weight (nano::unique_lock<nano::mutex> & lock_a,
// If count of tally items is less than 10, remove any block without tally // If count of tally items is less than 10, remove any block without tally
for (auto const & [hash, block] : blocks ()) for (auto const & [hash, block] : blocks ())
{ {
if (std::find_if (sorted.begin (), sorted.end (), [& hash = hash](auto const & item_a) { return item_a.first == hash; }) == sorted.end () && hash != winner_hash) if (std::find_if (sorted.begin (), sorted.end (), [&hash = hash] (auto const & item_a) { return item_a.first == hash; }) == sorted.end () && hash != winner_hash)
{ {
replaced_block = hash; replaced_block = hash;
break; break;
@ -630,6 +630,6 @@ std::vector<nano::vote_with_weight_info> nano::election::votes_with_weight () co
} }
} }
result.reserve (sorted_votes.size ()); result.reserve (sorted_votes.size ());
std::transform (sorted_votes.begin (), sorted_votes.end (), std::back_inserter (result), [](auto const & entry) { return entry.second; }); std::transform (sorted_votes.begin (), sorted_votes.end (), std::back_inserter (result), [] (auto const & entry) { return entry.second; });
return result; return result;
} }

6
nano/node/election.hpp
View file

@ -62,8 +62,8 @@ class election final : public std::enable_shared_from_this<nano::election>
{ {
// Minimum time between broadcasts of the current winner of an election, as a backup to requesting confirmations // Minimum time between broadcasts of the current winner of an election, as a backup to requesting confirmations
std::chrono::milliseconds base_latency () const; std::chrono::milliseconds base_latency () const;
std::function<void(std::shared_ptr<nano::block> const &)> confirmation_action; std::function<void (std::shared_ptr<nano::block> const &)> confirmation_action;
std::function<void(nano::account const &)> live_vote_action; std::function<void (nano::account const &)> live_vote_action;
private: // State management private: // State management
enum class state_t enum class state_t
@ -111,7 +111,7 @@ public: // Status
nano::election_status status; nano::election_status status;
public: // Interface public: // Interface
election (nano::node &, std::shared_ptr<nano::block> const &, std::function<void(std::shared_ptr<nano::block> const &)> const &, std::function<void(nano::account const &)> const &, bool, nano::election_behavior); election (nano::node &, std::shared_ptr<nano::block> const &, std::function<void (std::shared_ptr<nano::block> const &)> const &, std::function<void (nano::account const &)> const &, bool, nano::election_behavior);
std::shared_ptr<nano::block> find (nano::block_hash const &) const; std::shared_ptr<nano::block> find (nano::block_hash const &) const;
nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &); nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &);
bool publish (std::shared_ptr<nano::block> const & block_a); bool publish (std::shared_ptr<nano::block> const & block_a);

10
nano/node/gap_cache.cpp
View file

@ -5,7 +5,7 @@
#include <boost/format.hpp> #include <boost/format.hpp>
nano::gap_cache::gap_cache (nano::node & node_a) : nano::gap_cache::gap_cache (nano::node & node_a) :
node (node_a) node (node_a)
{ {
} }
@ -15,7 +15,7 @@ void nano::gap_cache::add (nano::block_hash const & hash_a, std::chrono::steady_
auto existing (blocks.get<tag_hash> ().find (hash_a)); auto existing (blocks.get<tag_hash> ().find (hash_a));
if (existing != blocks.get<tag_hash> ().end ()) if (existing != blocks.get<tag_hash> ().end ())
{ {
blocks.get<tag_hash> ().modify (existing, [time_point_a](nano::gap_information & info) { blocks.get<tag_hash> ().modify (existing, [time_point_a] (nano::gap_information & info) {
info.arrival = time_point_a; info.arrival = time_point_a;
}); });
} }
@ -45,7 +45,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> const & vote_a)
if (existing != gap_blocks_by_hash.end () && !existing->bootstrap_started) if (existing != gap_blocks_by_hash.end () && !existing->bootstrap_started)
{ {
auto is_new (false); auto is_new (false);
gap_blocks_by_hash.modify (existing, [&is_new, &vote_a](nano::gap_information & info) { gap_blocks_by_hash.modify (existing, [&is_new, &vote_a] (nano::gap_information & info) {
auto it = std::find (info.voters.begin (), info.voters.end (), vote_a->account); auto it = std::find (info.voters.begin (), info.voters.end (), vote_a->account);
is_new = (it == info.voters.end ()); is_new = (it == info.voters.end ());
if (is_new) if (is_new)
@ -58,7 +58,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> const & vote_a)
{ {
if (bootstrap_check (existing->voters, hash)) if (bootstrap_check (existing->voters, hash))
{ {
gap_blocks_by_hash.modify (existing, [](nano::gap_information & info) { gap_blocks_by_hash.modify (existing, [] (nano::gap_information & info) {
info.bootstrap_started = true; info.bootstrap_started = true;
}); });
} }
@ -96,7 +96,7 @@ bool nano::gap_cache::bootstrap_check (std::vector<nano::account> const & voters
void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a) void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a)
{ {
auto node_l (node.shared ()); auto node_l (node.shared ());
node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.bootstrap.gap_cache_bootstrap_start_interval, [node_l, hash_a]() { node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.bootstrap.gap_cache_bootstrap_start_interval, [node_l, hash_a] () {
if (!node_l->ledger.block_or_pruned_exists (hash_a)) if (!node_l->ledger.block_or_pruned_exists (hash_a))
{ {
if (!node_l->bootstrap_initiator.in_progress ()) if (!node_l->bootstrap_initiator.in_progress ())

12
nano/node/ipc/action_handler.cpp
View file

@ -40,9 +40,9 @@ auto get_message (nanoapi::Envelope const & envelope)
* Mapping from message type to handler function. * Mapping from message type to handler function.
* @note This must be updated whenever a new message type is added to the Flatbuffers IDL. * @note This must be updated whenever a new message type is added to the Flatbuffers IDL.
*/ */
auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Message, std::function<void(nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash> auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Message, std::function<void (nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>
{ {
static std::unordered_map<nanoapi::Message, std::function<void(nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash> handlers; static std::unordered_map<nanoapi::Message, std::function<void (nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash> handlers;
if (handlers.empty ()) if (handlers.empty ())
{ {
handlers.emplace (nanoapi::Message::Message_IsAlive, &nano::ipc::action_handler::on_is_alive); handlers.emplace (nanoapi::Message::Message_IsAlive, &nano::ipc::action_handler::on_is_alive);
@ -56,10 +56,10 @@ auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Me
} }
nano::ipc::action_handler::action_handler (nano::node & node_a, nano::ipc::ipc_server & server_a, std::weak_ptr<nano::ipc::subscriber> const & subscriber_a, std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) : nano::ipc::action_handler::action_handler (nano::node & node_a, nano::ipc::ipc_server & server_a, std::weak_ptr<nano::ipc::subscriber> const & subscriber_a, std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) :
flatbuffer_producer (builder_a), flatbuffer_producer (builder_a),
node (node_a), node (node_a),
ipc_server (server_a), ipc_server (server_a),
subscriber (subscriber_a) subscriber (subscriber_a)
{ {
} }

2
nano/node/ipc/action_handler.hpp
View file

@ -53,7 +53,7 @@ namespace ipc
void on_topic_service_stop (nanoapi::Envelope const & envelope); void on_topic_service_stop (nanoapi::Envelope const & envelope);
/** Returns a mapping from api message types to handler functions */ /** Returns a mapping from api message types to handler functions */
static auto handler_map () -> std::unordered_map<nanoapi::Message, std::function<void(action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>; static auto handler_map () -> std::unordered_map<nanoapi::Message, std::function<void (action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>;
private: private:
bool has_access (nanoapi::Envelope const & envelope_a, nano::ipc::access_permission permission_a) const noexcept; bool has_access (nanoapi::Envelope const & envelope_a, nano::ipc::access_permission permission_a) const noexcept;

Some files were not shown because too many files have changed in this diff Show more