diff --git a/CMakeLists.txt b/CMakeLists.txt index 0318dbd67e..a67294efd3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -53,6 +53,9 @@ set (NANO_FUZZER_TEST OFF CACHE BOOL "") option (NANO_STACKTRACE_BACKTRACE "Use BOOST_STACKTRACE_USE_BACKTRACE in stacktraces, for POSIX" OFF) if (NANO_STACKTRACE_BACKTRACE) add_definitions(-DNANO_STACKTRACE_BACKTRACE=1) + if (BACKTRACE_INCLUDE) + add_definitions(-DBOOST_STACKTRACE_BACKTRACE_INCLUDE_FILE=${BACKTRACE_INCLUDE}) + endif() endif () if (${NANO_TIMED_LOCKS} GREATER 0) diff --git a/ci/actions/windows/build.ps1 b/ci/actions/windows/build.ps1 index 5525f913e6..9fe4dc7d47 100644 --- a/ci/actions/windows/build.ps1 +++ b/ci/actions/windows/build.ps1 @@ -1,5 +1,4 @@ -# Stop immediately if any error happens -$ErrorActionPreference = "Stop" +$ErrorActionPreference = "Continue" if (${env:artifact} -eq 1) { if ( ${env:BETA} -eq 1 ) { diff --git a/ci/actions/windows/deploy.ps1 b/ci/actions/windows/deploy.ps1 index 948df01f4e..2e766bf23d 100644 --- a/ci/actions/windows/deploy.ps1 +++ b/ci/actions/windows/deploy.ps1 @@ -1,5 +1,4 @@ -# Stop immediately if any error happens -$ErrorActionPreference = "Stop" +$ErrorActionPreference = "Continue" if ( ${env:BETA} -eq 1 ) { $network_cfg="beta" diff --git a/ci/actions/windows/disable_windows_defender.ps1 b/ci/actions/windows/disable_windows_defender.ps1 index 3184a2634a..4d674308e9 100644 --- a/ci/actions/windows/disable_windows_defender.ps1 +++ b/ci/actions/windows/disable_windows_defender.ps1 @@ -1,3 +1,5 @@ +$ErrorActionPreference = "Continue" + Set-MpPreference -DisableArchiveScanning $true Set-MpPreference -DisableRealtimeMonitoring $true Set-MpPreference -DisableBehaviorMonitoring $true \ No newline at end of file diff --git a/ci/actions/windows/install_deps.ps1 b/ci/actions/windows/install_deps.ps1 index 3bf40e6ee7..29909727b7 100644 --- a/ci/actions/windows/install_deps.ps1 +++ b/ci/actions/windows/install_deps.ps1 @@ -1,3 +1,5 @@ +$ErrorActionPreference = "Continue" + function Get-RedirectedUri { <# .SYNOPSIS diff --git a/ci/actions/windows/signing.ps1 b/ci/actions/windows/signing.ps1 index 4cbe63f772..78de388617 100644 --- a/ci/actions/windows/signing.ps1 +++ b/ci/actions/windows/signing.ps1 @@ -1,3 +1,5 @@ +$ErrorActionPreference = "Continue" + if (Test-Path env:CSC_LINK) { $path = Join-Path -Path "$env:TMP" -ChildPath csc.p12 [IO.File]::WriteAllBytes($path, [Convert]::FromBase64String($env:CSC_LINK)) diff --git a/ci/build-travis.sh b/ci/build-travis.sh index e8da49f10d..f56c3076f1 100755 --- a/ci/build-travis.sh +++ b/ci/build-travis.sh @@ -10,16 +10,22 @@ OS=`uname` # This is to prevent out of scope access in async_write from asio which is not picked up by static analysers if [[ $(grep -rl --exclude="*asio.hpp" "asio::async_write" ./nano) ]]; then - echo "using boost::asio::async_write directly is not permitted (except in nano/lib/asio.hpp). Use nano::async_write instead" + echo "Using boost::asio::async_write directly is not permitted (except in nano/lib/asio.hpp). Use nano::async_write instead" exit 1 fi # prevent unsolicited use of std::lock_guard & std::unique_lock outside of allowed areas if [[ $(grep -rl --exclude={"*random_pool.cpp","*random_pool.hpp","*random_pool_shuffle.hpp","*locks.hpp","*locks.cpp"} "std::unique_lock\|std::lock_guard\|std::condition_variable" ./nano) ]]; then - echo "using std::unique_lock, std::lock_guard or std::condition_variable is not permitted (except in nano/lib/locks.hpp and non-nano dependent libraries). Use the nano::* versions instead" + echo "Using std::unique_lock, std::lock_guard or std::condition_variable is not permitted (except in nano/lib/locks.hpp and non-nano dependent libraries). Use the nano::* versions instead" exit 1 fi +if [[ $(grep -rlP "^\s*assert \(" ./nano) ]]; then + echo "Using assert is not permitted. Use debug_assert instead." + exit 1 +fi + +# prevent unsolicited use of std::lock_guard & std::unique_lock outside of allowed areas mkdir build pushd build @@ -44,8 +50,15 @@ ulimit -S -n 8192 if [[ "$OS" == 'Linux' ]]; then ROCKSDB="-DROCKSDB_LIBRARIES=/tmp/rocksdb/lib/librocksdb.a \ -DROCKSDB_INCLUDE_DIRS=/tmp/rocksdb/include" + if clang --version; then + BACKTRACE="-DNANO_STACKTRACE_BACKTRACE=ON \ + -DBACKTRACE_INCLUDE=" + else + BACKTRACE="-DNANO_STACKTRACE_BACKTRACE=ON" + fi else ROCKSDB="" + BACKTRACE="" fi cmake \ @@ -61,6 +74,7 @@ cmake \ -DBOOST_ROOT=/tmp/boost/ \ -DQt5_DIR=${qt_dir} \ -DCI_TEST="1" \ + ${BACKTRACE} \ ${SANITIZERS} \ .. diff --git a/docker/ci/Dockerfile-clang b/docker/ci/Dockerfile-clang index 6d1ba36590..dd6cfdab3c 100644 --- a/docker/ci/Dockerfile-clang +++ b/docker/ci/Dockerfile-clang @@ -14,6 +14,11 @@ RUN update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100 RUN update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100 ENV BOOST_ROOT=/tmp/boost -ADD util/build_prep/fetch_boost.sh fetch_boost.sh +ADD util/build_prep/bootstrap_boost.sh bootstrap_boost.sh +RUN ./bootstrap_boost.sh -m -c -B 1.70 -RUN ./fetch_boost.sh +# workaround to get a path that can be easily passed into cmake for +# BOOST_STACKTRACE_BACKTRACE_INCLUDE_FILE +# see https://www.boost.org/doc/libs/1_70_0/doc/html/stacktrace/configuration_and_build.html#stacktrace.configuration_and_build.f3 + +RUN ln -s /usr/lib/gcc/x86_64-linux-gnu/5/include/backtrace.h /tmp/backtrace.h \ No newline at end of file diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 49eca4891a..64eca0e740 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -370,7 +370,6 @@ TEST (active_transactions, inactive_votes_cache) } node.process_active (send); node.block_processor.flush (); - bool confirmed (false); system.deadline_set (5s); while (!node.ledger.block_confirmed (node.store.tx_begin_read (), send->hash ())) { diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 7cf0596a69..289e4adc99 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -727,7 +727,7 @@ TEST (block_store, large_iteration) for (auto i (store->latest_begin (transaction, 0)), n (store->latest_end ()); i != n; ++i) { nano::account current (i->first); - assert (current.number () > previous.number ()); + ASSERT_GT (current.number (), previous.number ()); accounts2.insert (current); previous = current; } @@ -873,8 +873,7 @@ TEST (mdb_block_store, upgrade_v2_v3) auto rep_block = ledger.representative (transaction, ledger.latest (transaction, nano::test_genesis_key.pub)); nano::account_info_v5 info_old (info.head, rep_block, info.open_block, info.balance, info.modified); auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (nano::test_genesis_key.pub), nano::mdb_val (sizeof (info_old), &info_old), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); store.confirmation_height_del (transaction, nano::genesis_account); } nano::logger_mt logger; @@ -2320,7 +2319,7 @@ void write_sideband_v15 (nano::mdb_store & store_a, nano::transaction & transact auto block = store_a.block_get (transaction_a, block_a.hash (), &sideband); ASSERT_NE (block, nullptr); - assert (sideband.details.epoch <= nano::epoch::max); + ASSERT_LE (sideband.details.epoch, nano::epoch::max); // Simulated by writing 0 on every of the most significant bits, leaving out epoch only, as if pre-upgrade nano::block_sideband sideband_v15 (sideband.type, sideband.account, sideband.successor, sideband.balance, sideband.timestamp, sideband.height, sideband.details.epoch, false, false, false); std::vector data; @@ -2341,8 +2340,7 @@ void modify_account_info_to_v13 (nano::mdb_store & store, nano::transaction cons ASSERT_FALSE (store.account_get (transaction, account, info)); nano::account_info_v13 account_info_v13 (info.head, rep_block, info.open_block, info.balance, info.modified, info.block_count, info.epoch ()); auto status (mdb_put (store.env.tx (transaction), (info.epoch () == nano::epoch::epoch_0) ? store.accounts_v0 : store.accounts_v1, nano::mdb_val (account), nano::mdb_val (account_info_v13), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); } void modify_account_info_to_v14 (nano::mdb_store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height, nano::block_hash const & rep_block) @@ -2351,15 +2349,13 @@ void modify_account_info_to_v14 (nano::mdb_store & store, nano::transaction cons ASSERT_FALSE (store.account_get (transaction, account, info)); nano::account_info_v14 account_info_v14 (info.head, rep_block, info.open_block, info.balance, info.modified, info.block_count, confirmation_height, info.epoch ()); auto status (mdb_put (store.env.tx (transaction), info.epoch () == nano::epoch::epoch_0 ? store.accounts_v0 : store.accounts_v1, nano::mdb_val (account), nano::mdb_val (account_info_v14), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); } void modify_confirmation_height_to_v15 (nano::mdb_store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height) { auto status (mdb_put (store.env.tx (transaction), store.confirmation_height, nano::mdb_val (account), nano::mdb_val (confirmation_height), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); } void modify_genesis_account_info_to_v5 (nano::mdb_store & store, nano::transaction const & transaction) @@ -2370,7 +2366,6 @@ void modify_genesis_account_info_to_v5 (nano::mdb_store & store, nano::transacti visitor.compute (info.head); nano::account_info_v5 info_old (info.head, visitor.result, info.open_block, info.balance, info.modified); auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (nano::test_genesis_key.pub), nano::mdb_val (sizeof (info_old), &info_old), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); } } diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index ecb25b01f4..426debef75 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -10,19 +10,21 @@ using namespace std::chrono_literals; namespace { -void add_callback_stats (nano::node & node, std::vector * observer_order = nullptr) +void add_callback_stats (nano::node & node, std::vector * observer_order = nullptr, std::mutex * mutex = nullptr) { - node.observers.blocks.add ([& stats = node.stats, observer_order](nano::election_status const & status_a, nano::account const &, nano::amount const &, bool) { + node.observers.blocks.add ([& stats = node.stats, observer_order, mutex](nano::election_status const & status_a, nano::account const &, nano::amount const &, bool) { stats.inc (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out); - if (observer_order) + if (mutex) { + nano::lock_guard guard (*mutex); + debug_assert (observer_order); observer_order->push_back (status_a.winner->hash ()); } }); } nano::stat::detail get_stats_detail (nano::confirmation_height_mode mode_a) { - assert (mode_a == nano::confirmation_height_mode::bounded || mode_a == nano::confirmation_height_mode::unbounded); + debug_assert (mode_a == nano::confirmation_height_mode::bounded || mode_a == nano::confirmation_height_mode::unbounded); return (mode_a == nano::confirmation_height_mode::bounded) ? nano::stat::detail::blocks_confirmed_bounded : nano::stat::detail::blocks_confirmed_unbounded; } } @@ -1270,7 +1272,8 @@ TEST (confirmation_height, cemented_gap_below_receive) } std::vector observer_order; - add_callback_stats (*node, &observer_order); + std::mutex mutex; + add_callback_stats (*node, &observer_order, &mutex); node->block_confirm (open1); system.deadline_set (10s); @@ -1289,6 +1292,7 @@ TEST (confirmation_height, cemented_gap_below_receive) // Check that the order of callbacks is correct std::vector expected_order = { send.hash (), open.hash (), send1.hash (), receive1.hash (), send2.hash (), dummy_send.hash (), receive2.hash (), dummy_send1.hash (), send3.hash (), open1->hash () }; + nano::lock_guard guard (mutex); ASSERT_EQ (observer_order, expected_order); }; diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index cb4b512249..8be720b051 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -12,15 +12,16 @@ TEST (confirmation_solicitor, batches) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.enable_voting = false; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - auto & node1 = *system.add_node (node_config); - auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); - // Solicitor will only solicit from this representative - nano::representative representative (nano::test_genesis_key.pub, nano::genesis_amount, channel1); - node_config.peering_port = nano::get_available_port (); nano::node_flags node_flags; + node_flags.disable_udp = false; + auto & node1 = *system.add_node (node_config, node_flags); + node_config.peering_port = nano::get_available_port (); // To prevent races on the solicitor node_flags.disable_request_loop = true; auto & node2 = *system.add_node (node_config, node_flags); + // Solicitor will only solicit from this representative + auto channel1 (node2.network.udp_channels.create (node1.network.endpoint ())); + nano::representative representative (nano::test_genesis_key.pub, nano::genesis_amount, channel1); // Lock active_transactions which uses the solicitor { nano::lock_guard active_guard (node2.active.mutex); @@ -43,6 +44,7 @@ TEST (confirmation_solicitor, batches) // Broadcasting should be immediate ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); ASSERT_FALSE (node2.active.solicitor.broadcast (*election)); + system.deadline_set (5s); while (node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out) < 1) { ASSERT_NO_ERROR (system.poll ()); diff --git a/nano/core_test/fakes/websocket_client.hpp b/nano/core_test/fakes/websocket_client.hpp index e0d9664ad9..895b8bcd4b 100644 --- a/nano/core_test/fakes/websocket_client.hpp +++ b/nano/core_test/fakes/websocket_client.hpp @@ -45,14 +45,14 @@ class fake_websocket_client void await_ack () { - assert (socket->is_open ()); + debug_assert (socket->is_open ()); boost::beast::flat_buffer buffer; socket->read (buffer); } boost::optional get_response (std::chrono::seconds const deadline = 5s) { - assert (deadline > 0s); + debug_assert (deadline > 0s); boost::optional result; auto buffer (std::make_shared ()); socket->async_read (*buffer, [&result, &buffer, socket = this->socket](boost::beast::error_code const & ec, std::size_t const /*n*/) { diff --git a/nano/core_test/memory_pool.cpp b/nano/core_test/memory_pool.cpp index 0a97764a71..176d2b0e64 100644 --- a/nano/core_test/memory_pool.cpp +++ b/nano/core_test/memory_pool.cpp @@ -50,7 +50,7 @@ size_t get_allocated_size () std::vector allocated; record_allocations_new_delete_allocator alloc (&allocated); (void)std::allocate_shared> (alloc); - assert (allocated.size () == 1); + debug_assert (allocated.size () == 1); return allocated.front (); } } diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp index a0df312df0..ddc56ea9ee 100644 --- a/nano/core_test/network_filter.cpp +++ b/nano/core_test/network_filter.cpp @@ -10,7 +10,7 @@ TEST (network_filter, unit) { nano::genesis genesis; nano::network_filter filter (1); - auto one_block = [&genesis, &filter](std::shared_ptr const & block_a, bool expect_duplicate_a) { + auto one_block = [&filter](std::shared_ptr const & block_a, bool expect_duplicate_a) { nano::publish message (block_a); auto bytes (message.to_bytes ()); nano::bufferstream stream (bytes->data (), bytes->size ()); diff --git a/nano/core_test/node_telemetry.cpp b/nano/core_test/node_telemetry.cpp index fbc7a97013..c42b396cce 100644 --- a/nano/core_test/node_telemetry.cpp +++ b/nano/core_test/node_telemetry.cpp @@ -16,6 +16,8 @@ void compare_default_test_result_data (nano::telemetry_data const & telemetry_da TEST (node_telemetry, consolidate_data) { + auto time = 1582117035109; + // Pick specific values so that we can check both mode and average are working correctly nano::telemetry_data data; data.account_count = 2; @@ -31,6 +33,7 @@ TEST (node_telemetry, consolidate_data) data.minor_version = 1; data.patch_version = 4; data.pre_release_version = 6; + data.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time)); nano::telemetry_data data1; data1.account_count = 5; @@ -47,6 +50,7 @@ TEST (node_telemetry, consolidate_data) data1.patch_version = 3; data1.pre_release_version = 6; data1.maker = 2; + data1.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time + 1)); nano::telemetry_data data2; data2.account_count = 3; @@ -62,6 +66,7 @@ TEST (node_telemetry, consolidate_data) data2.minor_version = 1; data2.patch_version = 4; data2.pre_release_version = 6; + data2.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time)); std::vector all_data{ data, data1, data2 }; @@ -80,6 +85,7 @@ TEST (node_telemetry, consolidate_data) ASSERT_FALSE (consolidated_telemetry_data.patch_version.is_initialized ()); ASSERT_FALSE (consolidated_telemetry_data.pre_release_version.is_initialized ()); ASSERT_FALSE (consolidated_telemetry_data.maker.is_initialized ()); + ASSERT_EQ (*consolidated_telemetry_data.timestamp, std::chrono::system_clock::time_point (std::chrono::milliseconds (time))); // Modify the metrics which may be either the mode or averages to ensure all are tested. all_data[2].bandwidth_cap = 53; @@ -90,6 +96,7 @@ TEST (node_telemetry, consolidate_data) all_data[2].patch_version = 3; all_data[2].pre_release_version = 6; all_data[2].maker = 2; + all_data[2].timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time + 2)); auto consolidated_telemetry_data1 = nano::consolidate_telemetry_data (all_data); ASSERT_EQ (consolidated_telemetry_data1.major_version, 10); @@ -100,6 +107,7 @@ TEST (node_telemetry, consolidate_data) ASSERT_TRUE (consolidated_telemetry_data1.protocol_version == 11 || consolidated_telemetry_data1.protocol_version == 12 || consolidated_telemetry_data1.protocol_version == 13); ASSERT_EQ (consolidated_telemetry_data1.bandwidth_cap, 51); ASSERT_EQ (consolidated_telemetry_data1.genesis_block, nano::block_hash (3)); + ASSERT_EQ (*consolidated_telemetry_data1.timestamp, std::chrono::system_clock::time_point (std::chrono::milliseconds (time + 1))); // Test equality operator ASSERT_FALSE (consolidated_telemetry_data == consolidated_telemetry_data1); @@ -108,16 +116,19 @@ TEST (node_telemetry, consolidate_data) TEST (node_telemetry, consolidate_data_optional_data) { + auto time = 1582117035109; nano::telemetry_data data; data.major_version = 20; data.minor_version = 1; data.patch_version = 4; data.pre_release_version = 6; data.maker = 2; + data.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time)); nano::telemetry_data missing_minor; missing_minor.major_version = 20; missing_minor.patch_version = 4; + missing_minor.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (time + 3)); nano::telemetry_data missing_all_optional; @@ -128,6 +139,7 @@ TEST (node_telemetry, consolidate_data_optional_data) ASSERT_EQ (*consolidated_telemetry_data.patch_version, 4); ASSERT_EQ (*consolidated_telemetry_data.pre_release_version, 6); ASSERT_EQ (*consolidated_telemetry_data.maker, 2); + ASSERT_EQ (*consolidated_telemetry_data.timestamp, std::chrono::system_clock::time_point (std::chrono::milliseconds (time + 1))); } TEST (node_telemetry, serialize_deserialize_json_optional) @@ -137,6 +149,7 @@ TEST (node_telemetry, serialize_deserialize_json_optional) data.patch_version = 4; data.pre_release_version = 6; data.maker = 2; + data.timestamp = std::chrono::system_clock::time_point (100ms); nano::jsonconfig config; data.serialize_json (config); @@ -150,6 +163,9 @@ TEST (node_telemetry, serialize_deserialize_json_optional) ASSERT_EQ (val, 6); ASSERT_FALSE (config.get ("maker", val).get_error ()); ASSERT_EQ (val, 2); + uint64_t timestamp; + ASSERT_FALSE (config.get ("timestamp", timestamp).get_error ()); + ASSERT_EQ (timestamp, 100); nano::telemetry_data data1; data1.deserialize_json (config); @@ -157,6 +173,7 @@ TEST (node_telemetry, serialize_deserialize_json_optional) ASSERT_EQ (*data1.patch_version, 4); ASSERT_EQ (*data1.pre_release_version, 6); ASSERT_EQ (*data1.maker, 2); + ASSERT_EQ (*data1.timestamp, std::chrono::system_clock::time_point (100ms)); nano::telemetry_data no_optional_data; nano::jsonconfig config1; @@ -165,6 +182,7 @@ TEST (node_telemetry, serialize_deserialize_json_optional) ASSERT_FALSE (config1.get_optional ("patch_version").is_initialized ()); ASSERT_FALSE (config1.get_optional ("pre_release_version").is_initialized ()); ASSERT_FALSE (config1.get_optional ("maker").is_initialized ()); + ASSERT_FALSE (config1.get_optional ("timestamp").is_initialized ()); nano::telemetry_data no_optional_data1; no_optional_data1.deserialize_json (config1); @@ -172,6 +190,7 @@ TEST (node_telemetry, serialize_deserialize_json_optional) ASSERT_FALSE (no_optional_data1.patch_version.is_initialized ()); ASSERT_FALSE (no_optional_data1.pre_release_version.is_initialized ()); ASSERT_FALSE (no_optional_data1.maker.is_initialized ()); + ASSERT_FALSE (no_optional_data1.timestamp.is_initialized ()); } TEST (node_telemetry, consolidate_data_remove_outliers) @@ -191,6 +210,7 @@ TEST (node_telemetry, consolidate_data_remove_outliers) data.patch_version = 5; data.pre_release_version = 2; data.maker = 1; + data.timestamp = std::chrono::system_clock::time_point (100ms); // Insert 20 of these, and 2 outliers at the lower and upper bounds which should get removed std::vector all_data (20, data); @@ -211,6 +231,7 @@ TEST (node_telemetry, consolidate_data_remove_outliers) outlier_data.patch_version = 1; outlier_data.pre_release_version = 1; outlier_data.maker = 1; + outlier_data.timestamp = std::chrono::system_clock::time_point (1ms); all_data.push_back (outlier_data); all_data.push_back (outlier_data); @@ -229,6 +250,7 @@ TEST (node_telemetry, consolidate_data_remove_outliers) outlier_data1.patch_version = 9; outlier_data1.pre_release_version = 9; outlier_data1.maker = 9; + outlier_data1.timestamp = std::chrono::system_clock::time_point (999ms); all_data.push_back (outlier_data1); all_data.push_back (outlier_data1); @@ -242,7 +264,7 @@ TEST (node_telemetry, no_peers) std::atomic done{ false }; system.nodes[0]->telemetry.get_metrics_peers_async ([&done](nano::telemetry_data_responses const & responses_a) { - ASSERT_TRUE (responses_a.telemetry_data_time_pairs.empty ()); + ASSERT_TRUE (responses_a.telemetry_datas.empty ()); ASSERT_FALSE (responses_a.all_received); done = true; }); @@ -267,12 +289,12 @@ TEST (node_telemetry, basic) wait_peer_connections (system); // Request telemetry metrics - std::unordered_map all_telemetry_data_time_pairs; + std::unordered_map all_telemetry_datas; { std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - all_telemetry_data_time_pairs = responses_a.telemetry_data_time_pairs; + all_telemetry_datas = responses_a.telemetry_datas; done = true; }); @@ -284,14 +306,14 @@ TEST (node_telemetry, basic) } // Check the metrics are correct - ASSERT_EQ (all_telemetry_data_time_pairs.size (), 1); - compare_default_test_result_data (all_telemetry_data_time_pairs.begin ()->second.data, *node_server); + ASSERT_EQ (all_telemetry_datas.size (), 1); + compare_default_test_result_data (all_telemetry_datas.begin ()->second, *node_server); // Call again straight away. It should use the cache { std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { - ASSERT_EQ (all_telemetry_data_time_pairs, responses_a.telemetry_data_time_pairs); + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { + ASSERT_EQ (all_telemetry_datas, responses_a.telemetry_datas); ASSERT_TRUE (responses_a.all_received); done = true; }); @@ -307,8 +329,8 @@ TEST (node_telemetry, basic) std::this_thread::sleep_for (nano::telemetry_cache_cutoffs::test); std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { - ASSERT_NE (all_telemetry_data_time_pairs, responses_a.telemetry_data_time_pairs); + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { + ASSERT_NE (all_telemetry_datas, responses_a.telemetry_datas); ASSERT_TRUE (responses_a.all_received); done = true; }); @@ -350,10 +372,10 @@ TEST (node_telemetry, many_nodes) auto node_client = system.nodes.front (); std::atomic done{ false }; - std::unordered_map all_telemetry_data_time_pairs; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { + std::unordered_map all_telemetry_datas; + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - all_telemetry_data_time_pairs = responses_a.telemetry_data_time_pairs; + all_telemetry_datas = responses_a.telemetry_datas; done = true; }); @@ -365,9 +387,9 @@ TEST (node_telemetry, many_nodes) // Check the metrics nano::network_params params; - for (auto & telemetry_data_time_pair : all_telemetry_data_time_pairs) + for (auto & telemetry_data : all_telemetry_datas) { - auto & data = telemetry_data_time_pair.second.data; + auto & data = telemetry_data.second; ASSERT_EQ (data.unchecked_count, 0); ASSERT_EQ (data.cemented_count, 1); ASSERT_LE (data.peer_count, 9); @@ -386,10 +408,10 @@ TEST (node_telemetry, many_nodes) } // We gave some nodes different bandwidth caps, confirm they are not all the same - auto bandwidth_cap = all_telemetry_data_time_pairs.begin ()->second.data.bandwidth_cap; - all_telemetry_data_time_pairs.erase (all_telemetry_data_time_pairs.begin ()); - auto all_bandwidth_limits_same = std::all_of (all_telemetry_data_time_pairs.begin (), all_telemetry_data_time_pairs.end (), [bandwidth_cap](auto & telemetry_data_time_pair) { - return telemetry_data_time_pair.second.data.bandwidth_cap == bandwidth_cap; + auto bandwidth_cap = all_telemetry_datas.begin ()->second.bandwidth_cap; + all_telemetry_datas.erase (all_telemetry_datas.begin ()); + auto all_bandwidth_limits_same = std::all_of (all_telemetry_datas.begin (), all_telemetry_datas.end (), [bandwidth_cap](auto & telemetry_data) { + return telemetry_data.second.bandwidth_cap == bandwidth_cap; }); ASSERT_FALSE (all_bandwidth_limits_same); } @@ -416,10 +438,10 @@ TEST (node_telemetry, over_udp) wait_peer_connections (system); std::atomic done{ false }; - std::unordered_map all_telemetry_data_time_pairs; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { + std::unordered_map all_telemetry_datas; + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - all_telemetry_data_time_pairs = responses_a.telemetry_data_time_pairs; + all_telemetry_datas = responses_a.telemetry_datas; done = true; }); @@ -429,8 +451,8 @@ TEST (node_telemetry, over_udp) ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (all_telemetry_data_time_pairs.size (), 1); - compare_default_test_result_data (all_telemetry_data_time_pairs.begin ()->second.data, *node_server); + ASSERT_EQ (all_telemetry_datas.size (), 1); + compare_default_test_result_data (all_telemetry_datas.begin ()->second, *node_server); // Check channels are indeed udp ASSERT_EQ (1, node_client->network.size ()); @@ -458,14 +480,14 @@ TEST (node_telemetry, single_request) // Request telemetry metrics auto channel = node_client->network.find_channel (node_server->network.endpoint ()); - nano::telemetry_data_time_pair telemetry_data_time_pair; + nano::telemetry_data telemetry_data; { std::atomic done{ false }; - node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data_time_pair, &channel](nano::telemetry_data_response const & response_a) { + node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data, &channel](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); ASSERT_EQ (channel->get_endpoint (), response_a.endpoint); - telemetry_data_time_pair = response_a.telemetry_data_time_pair; + telemetry_data = response_a.telemetry_data; done = true; }); @@ -477,13 +499,13 @@ TEST (node_telemetry, single_request) } // Check the metrics are correct - compare_default_test_result_data (telemetry_data_time_pair.data, *node_server); + compare_default_test_result_data (telemetry_data, *node_server); // Call again straight away. It should use the cache { std::atomic done{ false }; - node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data_time_pair](nano::telemetry_data_response const & response_a) { - ASSERT_EQ (telemetry_data_time_pair, response_a.telemetry_data_time_pair); + 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_FALSE (response_a.error); done = true; }); @@ -499,8 +521,8 @@ TEST (node_telemetry, single_request) std::this_thread::sleep_for (nano::telemetry_cache_cutoffs::test); std::atomic done{ false }; - node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data_time_pair](nano::telemetry_data_response const & response_a) { - ASSERT_NE (telemetry_data_time_pair, response_a.telemetry_data_time_pair); + 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_FALSE (response_a.error); done = true; }); @@ -565,13 +587,13 @@ TEST (node_telemetry, blocking_single_and_random) // Blocking version of get_random_metrics_async auto telemetry_data_responses = node_client->telemetry.get_metrics_peers (); ASSERT_TRUE (telemetry_data_responses.all_received); - compare_default_test_result_data (telemetry_data_responses.telemetry_data_time_pairs.begin ()->second.data, *node_server); + compare_default_test_result_data (telemetry_data_responses.telemetry_datas.begin ()->second, *node_server); // Now try single request metric auto telemetry_data_response = node_client->telemetry.get_metrics_single_peer (node_client->network.find_channel (node_server->network.endpoint ())); ASSERT_FALSE (telemetry_data_response.error); - compare_default_test_result_data (telemetry_data_response.telemetry_data_time_pair.data, *node_server); - ASSERT_EQ (telemetry_data_response.telemetry_data_time_pair.last_updated, telemetry_data_responses.telemetry_data_time_pairs.begin ()->second.last_updated); + compare_default_test_result_data (telemetry_data_response.telemetry_data, *node_server); + ASSERT_EQ (*telemetry_data_response.telemetry_data.timestamp, *telemetry_data_responses.telemetry_datas.begin ()->second.timestamp); done = true; promise.get_future ().wait (); @@ -596,10 +618,10 @@ TEST (node_telemetry, multiple_single_request_clearing) auto channel = node_client->network.find_channel (node_server->network.endpoint ()); std::atomic done{ false }; - std::chrono::steady_clock::time_point last_updated; + std::chrono::system_clock::time_point last_updated; node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &last_updated](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); - last_updated = response_a.telemetry_data_time_pair.last_updated; + last_updated = *response_a.telemetry_data.timestamp; done = true; }); @@ -615,12 +637,10 @@ TEST (node_telemetry, multiple_single_request_clearing) system.deadline_set (10s); node_client->telemetry.get_metrics_single_peer_async (channel, [&done, last_updated](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); - ASSERT_EQ (last_updated, response_a.telemetry_data_time_pair.last_updated); + ASSERT_EQ (last_updated, *response_a.telemetry_data.timestamp); done = true; }); - ASSERT_LT (last_updated, node_client->telemetry.single_requests.begin ()->second.last_updated); - system.deadline_set (10s); while (!done) { @@ -631,8 +651,8 @@ TEST (node_telemetry, multiple_single_request_clearing) auto channel1 = node_client->network.find_channel (node_server1->network.endpoint ()); node_client->telemetry.get_metrics_single_peer_async (channel1, [&done, &last_updated](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); - ASSERT_NE (last_updated, response_a.telemetry_data_time_pair.last_updated); - last_updated = response_a.telemetry_data_time_pair.last_updated; + ASSERT_NE (last_updated, *response_a.telemetry_data.timestamp); + last_updated = *response_a.telemetry_data.timestamp; done = true; }); @@ -646,7 +666,7 @@ TEST (node_telemetry, multiple_single_request_clearing) done = false; node_client->telemetry.get_metrics_single_peer_async (channel1, [&done, last_updated](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); - ASSERT_EQ (last_updated, response_a.telemetry_data_time_pair.last_updated); + ASSERT_EQ (last_updated, *response_a.telemetry_data.timestamp); done = true; }); @@ -712,12 +732,12 @@ TEST (node_telemetry, batch_use_single_request_cache) wait_peer_connections (system); // Request telemetry metrics - nano::telemetry_data_time_pair telemetry_data_time_pair; + nano::telemetry_data telemetry_data; { std::atomic done{ false }; auto channel = node_client->network.find_channel (node_server->network.endpoint ()); - node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data_time_pair](nano::telemetry_data_response const & response_a) { - telemetry_data_time_pair = response_a.telemetry_data_time_pair; + node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &telemetry_data](nano::telemetry_data_response const & response_a) { + telemetry_data = response_a.telemetry_data; done = true; }); @@ -730,9 +750,9 @@ TEST (node_telemetry, batch_use_single_request_cache) { std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &telemetry_data_time_pair](nano::telemetry_data_responses const & responses_a) { + node_client->telemetry.get_metrics_peers_async ([&done, &telemetry_data](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - ASSERT_EQ (telemetry_data_time_pair, responses_a.telemetry_data_time_pairs.begin ()->second); + ASSERT_EQ (telemetry_data, responses_a.telemetry_datas.begin ()->second); done = true; }); @@ -762,8 +782,8 @@ TEST (node_telemetry, batch_use_single_request_cache) system.deadline_set (10s); std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &telemetry_data_time_pair](nano::telemetry_data_responses const & responses_a) { - ASSERT_EQ (1, responses_a.telemetry_data_time_pairs.size ()); + node_client->telemetry.get_metrics_peers_async ([&done](nano::telemetry_data_responses const & responses_a) { + ASSERT_EQ (1, responses_a.telemetry_datas.size ()); done = true; }); @@ -792,13 +812,13 @@ TEST (node_telemetry, single_request_use_batch_cache) wait_peer_connections (system); // Request batched metric first - std::unordered_map all_telemetry_data_time_pairs; + std::unordered_map all_telemetry_datas; { std::atomic done{ false }; - node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_data_time_pairs](nano::telemetry_data_responses const & responses_a) { + node_client->telemetry.get_metrics_peers_async ([&done, &all_telemetry_datas](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - ASSERT_EQ (1, responses_a.telemetry_data_time_pairs.size ()); - all_telemetry_data_time_pairs = responses_a.telemetry_data_time_pairs; + ASSERT_EQ (1, responses_a.telemetry_datas.size ()); + all_telemetry_datas = responses_a.telemetry_datas; done = true; }); @@ -811,8 +831,8 @@ TEST (node_telemetry, single_request_use_batch_cache) std::atomic done{ false }; auto channel = node_client->network.find_channel (node_server->network.endpoint ()); - node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &all_telemetry_data_time_pairs](nano::telemetry_data_response const & response_a) { - ASSERT_EQ (all_telemetry_data_time_pairs.begin ()->second, response_a.telemetry_data_time_pair); + node_client->telemetry.get_metrics_single_peer_async (channel, [&done, &all_telemetry_datas](nano::telemetry_data_response const & response_a) { + ASSERT_EQ (all_telemetry_datas.begin ()->second, response_a.telemetry_data); ASSERT_FALSE (response_a.error); done = true; }); @@ -958,7 +978,7 @@ TEST (node_telemetry, disable_metrics_single) auto channel1 = node_server->network.find_channel (node_client->network.endpoint ()); node_server->telemetry.get_metrics_single_peer_async (channel1, [&done, node_server](nano::telemetry_data_response const & response_a) { ASSERT_FALSE (response_a.error); - compare_default_test_result_data (response_a.telemetry_data_time_pair.data, *node_server); + compare_default_test_result_data (response_a.telemetry_data, *node_server); done = true; }); @@ -999,7 +1019,7 @@ TEST (node_telemetry, disable_metrics_batch) done = false; node_server->telemetry.get_metrics_peers_async ([&done, node_server](nano::telemetry_data_responses const & responses_a) { ASSERT_TRUE (responses_a.all_received); - compare_default_test_result_data (responses_a.telemetry_data_time_pairs.begin ()->second.data, *node_server); + compare_default_test_result_data (responses_a.telemetry_datas.begin ()->second, *node_server); done = true; }); @@ -1036,12 +1056,13 @@ void compare_default_test_result_data (nano::telemetry_data const & telemetry_da ASSERT_EQ (telemetry_data_a.protocol_version, node_server_a.network_params.protocol.telemetry_protocol_version_min); ASSERT_EQ (telemetry_data_a.unchecked_count, 0); ASSERT_EQ (telemetry_data_a.account_count, 1); + ASSERT_LT (telemetry_data_a.uptime, 100); + ASSERT_EQ (telemetry_data_a.genesis_block, node_server_a.network_params.ledger.genesis_hash); ASSERT_EQ (telemetry_data_a.major_version, nano::get_major_node_version ()); ASSERT_EQ (*telemetry_data_a.minor_version, nano::get_minor_node_version ()); ASSERT_EQ (*telemetry_data_a.patch_version, nano::get_patch_node_version ()); ASSERT_EQ (*telemetry_data_a.pre_release_version, nano::get_pre_release_node_version ()); ASSERT_EQ (*telemetry_data_a.maker, 0); - ASSERT_LT (telemetry_data_a.uptime, 100); - ASSERT_EQ (telemetry_data_a.genesis_block, node_server_a.network_params.ledger.genesis_hash); + ASSERT_GT (*telemetry_data_a.timestamp, std::chrono::system_clock::now () - 100s); } } diff --git a/nano/core_test/signing.cpp b/nano/core_test/signing.cpp index 44c0f5871d..6ac902d3b5 100644 --- a/nano/core_test/signing.cpp +++ b/nano/core_test/signing.cpp @@ -73,7 +73,7 @@ TEST (signature_checker, many_multi_threaded) for (int i = 0; i < num_check_sizes; ++i) { auto check_size = check_sizes[i]; - assert (check_size > 0); + ASSERT_GT (check_size, 0); auto last_signature_index = check_size - 1; messages[i].resize (check_size); diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index 76de566d01..c615379467 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -202,6 +202,7 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.logging.network_telemetry_logging_value, defaults.node.logging.network_telemetry_logging_value); ASSERT_EQ (conf.node.logging.rotation_size, defaults.node.logging.rotation_size); ASSERT_EQ (conf.node.logging.single_line_record_value, defaults.node.logging.single_line_record_value); + ASSERT_EQ (conf.node.logging.stable_log_filename, defaults.node.logging.stable_log_filename); ASSERT_EQ (conf.node.logging.timing_logging_value, defaults.node.logging.timing_logging_value); ASSERT_EQ (conf.node.logging.active_update_value, defaults.node.logging.active_update_value); ASSERT_EQ (conf.node.logging.upnp_details_logging_value, defaults.node.logging.upnp_details_logging_value); @@ -467,6 +468,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) node_lifetime_tracing = true rotation_size = 999 single_line_record = true + stable_log_filename = true timing = true active_update = true upnp_details = true @@ -598,6 +600,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.logging.node_lifetime_tracing_value, defaults.node.logging.node_lifetime_tracing_value); ASSERT_NE (conf.node.logging.rotation_size, defaults.node.logging.rotation_size); ASSERT_NE (conf.node.logging.single_line_record_value, defaults.node.logging.single_line_record_value); + ASSERT_NE (conf.node.logging.stable_log_filename, defaults.node.logging.stable_log_filename); ASSERT_NE (conf.node.logging.timing_logging_value, defaults.node.logging.timing_logging_value); ASSERT_NE (conf.node.logging.active_update_value, defaults.node.logging.active_update_value); ASSERT_NE (conf.node.logging.upnp_details_logging_value, defaults.node.logging.upnp_details_logging_value); diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 5ff9b92440..0ac38b5bef 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -57,7 +57,8 @@ TEST (vote_processor, flush) auto channel (std::make_shared (node.network.udp_channels, node.network.endpoint (), node.network_params.protocol.protocol_version)); for (unsigned i = 0; i < 2000; ++i) { - node.vote_processor.vote (vote, channel); + auto new_vote (std::make_shared (*vote)); + node.vote_processor.vote (new_vote, channel); ++vote->sequence; // invalidates votes without signing again } node.vote_processor.flush (); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index a3a851c1e1..d2bfe9775a 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -110,8 +110,7 @@ TEST (wallets, upgrade) auto rep_block = node1->rep_block (nano::genesis_account); nano::account_info_v13 account_info_v13 (info.head, rep_block, info.open_block, info.balance, info.modified, info.block_count, info.epoch ()); auto status (mdb_put (mdb_store.env.tx (transaction_destination), info.epoch () == nano::epoch::epoch_0 ? mdb_store.accounts_v0 : mdb_store.accounts_v1, nano::mdb_val (nano::test_genesis_key.pub), nano::mdb_val (account_info_v13), 0)); - (void)status; - assert (status == 0); + ASSERT_EQ (status, 0); mdb_store.confirmation_height_del (transaction_destination, nano::genesis_account); } auto node1 (std::make_shared (system.io_ctx, path, system.alarm, node_config1, system.work)); diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index ec94f81028..5729a3a0ee 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -85,6 +85,7 @@ target_compile_definitions(nano_lib -DMINOR_VERSION_STRING=${CPACK_PACKAGE_VERSION_MINOR} -DPATCH_VERSION_STRING=${CPACK_PACKAGE_VERSION_PATCH} -DPRE_RELEASE_VERSION_STRING=${CPACK_PACKAGE_VERSION_PRE_RELEASE} + -DCI=${CI_TEST} PUBLIC -DACTIVE_NETWORK=${ACTIVE_NETWORK} ) diff --git a/nano/lib/blockbuilders.cpp b/nano/lib/blockbuilders.cpp index 92935546ef..0a87b843c6 100644 --- a/nano/lib/blockbuilders.cpp +++ b/nano/lib/blockbuilders.cpp @@ -186,7 +186,7 @@ std::error_code check_fields_set (uint8_t block_all_flags, uint8_t build_state) { // Convert the first bit set to a field mask and look up the error code. auto build_flags_mask = static_cast (ffs_mask (res)); - assert (ec_map.find (build_flags_mask) != ec_map.end ()); + debug_assert (ec_map.find (build_flags_mask) != ec_map.end ()); ec = ec_map[build_flags_mask]; } return ec; @@ -658,7 +658,7 @@ std::unique_ptr nano::abstract_builder::build () { static_cast (this)->validate (); } - assert (!ec); + debug_assert (!ec); return std::move (block); } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 3c2bb81d6c..d4508ec5d2 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -55,7 +55,7 @@ size_t nano::block::size (nano::block_type type_a) { case nano::block_type::invalid: case nano::block_type::not_a_block: - assert (false); + debug_assert (false); break; case nano::block_type::send: result = nano::send_block::size; @@ -81,10 +81,10 @@ nano::block_hash nano::block::generate_hash () const nano::block_hash result; blake2b_state hash_l; auto status (blake2b_init (&hash_l, sizeof (result.bytes))); - assert (status == 0); + debug_assert (status == 0); hash (hash_l); status = blake2b_final (&hash_l, result.bytes.data (), sizeof (result.bytes)); - assert (status == 0); + debug_assert (status == 0); return result; } @@ -102,7 +102,7 @@ nano::block_hash const & nano::block::hash () const { // Once a block is created, it should not be modified (unless using refresh ()) // This would invalidate the cache; check it hasn't changed. - assert (cached_hash == generate_hash ()); + debug_assert (cached_hash == generate_hash ()); } else { @@ -228,11 +228,11 @@ nano::send_hashables::send_hashables (bool & error_a, boost::property_tree::ptre void nano::send_hashables::hash (blake2b_state & hash_a) const { auto status (blake2b_update (&hash_a, previous.bytes.data (), sizeof (previous.bytes))); - assert (status == 0); + debug_assert (status == 0); status = blake2b_update (&hash_a, destination.bytes.data (), sizeof (destination.bytes)); - assert (status == 0); + debug_assert (status == 0); status = blake2b_update (&hash_a, balance.bytes.data (), sizeof (balance.bytes)); - assert (status == 0); + debug_assert (status == 0); } void nano::send_block::serialize (nano::stream & stream_a) const @@ -293,7 +293,7 @@ bool nano::send_block::deserialize_json (boost::property_tree::ptree const & tre auto error (false); try { - assert (tree_a.get ("type") == "send"); + debug_assert (tree_a.get ("type") == "send"); auto previous_l (tree_a.get ("previous")); auto destination_l (tree_a.get ("destination")); auto balance_l (tree_a.get ("balance")); @@ -485,7 +485,7 @@ hashables (source_a, representative_a, account_a), signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { - 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) : @@ -614,7 +614,7 @@ bool nano::open_block::deserialize_json (boost::property_tree::ptree const & tre auto error (false); try { - assert (tree_a.get ("type") == "open"); + debug_assert (tree_a.get ("type") == "open"); auto source_l (tree_a.get ("source")); auto representative_l (tree_a.get ("representative")); auto account_l (tree_a.get ("account")); @@ -855,7 +855,7 @@ bool nano::change_block::deserialize_json (boost::property_tree::ptree const & t auto error (false); try { - assert (tree_a.get ("type") == "change"); + debug_assert (tree_a.get ("type") == "change"); auto previous_l (tree_a.get ("previous")); auto representative_l (tree_a.get ("representative")); auto work_l (tree_a.get ("work")); @@ -1147,7 +1147,7 @@ bool nano::state_block::deserialize_json (boost::property_tree::ptree const & tr auto error (false); try { - assert (tree_a.get ("type") == "state"); + debug_assert (tree_a.get ("type") == "state"); auto account_l (tree_a.get ("account")); auto previous_l (tree_a.get ("previous")); auto representative_l (tree_a.get ("representative")); @@ -1338,7 +1338,7 @@ std::shared_ptr nano::deserialize_block (nano::stream & stream_a, n } default: #ifndef NANO_FUZZER_TEST - assert (false); + debug_assert (false); #endif break; } @@ -1415,7 +1415,7 @@ bool nano::receive_block::deserialize_json (boost::property_tree::ptree const & auto error (false); try { - assert (tree_a.get ("type") == "receive"); + debug_assert (tree_a.get ("type") == "receive"); auto previous_l (tree_a.get ("previous")); auto source_l (tree_a.get ("source")); auto work_l (tree_a.get ("work")); diff --git a/nano/lib/errors.cpp b/nano/lib/errors.cpp index 7722b5950e..5f9971ce9d 100644 --- a/nano/lib/errors.cpp +++ b/nano/lib/errors.cpp @@ -1,9 +1,8 @@ -#include "nano/lib/errors.hpp" +#include +#include #include -#include - std::string nano::error_common_messages::message (int ev) const { switch (static_cast (ev)) @@ -291,7 +290,7 @@ std::error_code nano::error_conversion::convert (const boost::system::error_code return std::error_code (error.value (), nano::error_conversion::generic_category ()); } - assert (false); + debug_assert (false); return nano::error_common::invalid_type_conversion; } diff --git a/nano/lib/ipc.cpp b/nano/lib/ipc.cpp index dd109b1b65..41ae3cb5ca 100644 --- a/nano/lib/ipc.cpp +++ b/nano/lib/ipc.cpp @@ -1,4 +1,5 @@ #include +#include nano::ipc::socket_base::socket_base (boost::asio::io_context & io_ctx_a) : io_timer (io_ctx_a) @@ -28,7 +29,7 @@ void nano::ipc::socket_base::timer_cancel () { boost::system::error_code ec; io_timer.cancel (ec); - assert (!ec); + debug_assert (!ec); } nano::ipc::dsock_file_remover::dsock_file_remover (std::string const & file_a) : diff --git a/nano/lib/logger_mt.hpp b/nano/lib/logger_mt.hpp index b2746c6e5b..5f7744a4fe 100644 --- a/nano/lib/logger_mt.hpp +++ b/nano/lib/logger_mt.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -31,7 +32,7 @@ inline boost::log::formatting_ostream & operator<< (boost::log::formatting_ostre }; nano::severity_level level = manip.get (); - assert (static_cast (level) < strings.size ()); + debug_assert (static_cast (level) < strings.size ()); strm << strings[static_cast (level)]; return strm; } diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp index dc4346443c..fba48e109a 100644 --- a/nano/lib/numbers.cpp +++ b/nano/lib/numbers.cpp @@ -14,14 +14,14 @@ char const * account_lookup ("13456789abcdefghijkmnopqrstuwxyz"); char const * account_reverse ("~0~1234567~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~89:;<=>?@AB~CDEFGHIJK~LMNO~~~~~"); char account_encode (uint8_t value) { - assert (value < 32); + debug_assert (value < 32); auto result (account_lookup[value]); return result; } uint8_t account_decode (char value) { - assert (value >= '0'); - assert (value <= '~'); + debug_assert (value >= '0'); + debug_assert (value <= '~'); auto result (account_reverse[value - 0x30]); if (result != '~') { @@ -33,7 +33,7 @@ uint8_t account_decode (char value) void nano::public_key::encode_account (std::string & destination_a) const { - assert (destination_a.empty ()); + debug_assert (destination_a.empty ()); destination_a.reserve (65); uint64_t check (0); blake2b_state hash; @@ -200,7 +200,7 @@ nano::uint256_t nano::uint256_union::number () const void nano::uint256_union::encode_hex (std::string & text) const { - assert (text.empty ()); + debug_assert (text.empty ()); std::stringstream stream; stream << std::hex << std::uppercase << std::noshowbase << std::setw (64) << std::setfill ('0'); stream << number (); @@ -238,7 +238,7 @@ bool nano::uint256_union::decode_hex (std::string const & text) void nano::uint256_union::encode_dec (std::string & text) const { - assert (text.empty ()); + debug_assert (text.empty ()); std::stringstream stream; stream << std::dec << std::noshowbase; stream << number (); @@ -317,7 +317,7 @@ nano::uint512_t nano::uint512_union::number () const void nano::uint512_union::encode_hex (std::string & text) const { - assert (text.empty ()); + debug_assert (text.empty ()); std::stringstream stream; stream << std::hex << std::uppercase << std::noshowbase << std::setw (128) << std::setfill ('0'); stream << number (); @@ -481,7 +481,7 @@ nano::uint128_t nano::uint128_union::number () const void nano::uint128_union::encode_hex (std::string & text) const { - assert (text.empty ()); + debug_assert (text.empty ()); std::stringstream stream; stream << std::hex << std::uppercase << std::noshowbase << std::setw (32) << std::setfill ('0'); stream << number (); @@ -515,7 +515,7 @@ bool nano::uint128_union::decode_hex (std::string const & text) void nano::uint128_union::encode_dec (std::string & text) const { - assert (text.empty ()); + debug_assert (text.empty ()); std::stringstream stream; stream << std::dec << std::noshowbase; stream << number (); @@ -894,7 +894,7 @@ std::string nano::to_string (double const value_a, int const precision_a) uint64_t nano::difficulty::from_multiplier (double const multiplier_a, uint64_t const base_difficulty_a) { - assert (multiplier_a > 0.); + debug_assert (multiplier_a > 0.); nano::uint128_t reverse_difficulty ((-base_difficulty_a) / multiplier_a); if (reverse_difficulty > std::numeric_limits::max ()) { @@ -912,7 +912,7 @@ uint64_t nano::difficulty::from_multiplier (double const multiplier_a, uint64_t double nano::difficulty::to_multiplier (uint64_t const difficulty_a, uint64_t const base_difficulty_a) { - assert (difficulty_a > 0); + debug_assert (difficulty_a > 0); return static_cast (-base_difficulty_a) / (-difficulty_a); } diff --git a/nano/lib/plat/linux/debugging.cpp b/nano/lib/plat/linux/debugging.cpp index 1e9b4a9aee..f0a596cf68 100644 --- a/nano/lib/plat/linux/debugging.cpp +++ b/nano/lib/plat/linux/debugging.cpp @@ -1,6 +1,5 @@ #include -#include #include #include @@ -15,7 +14,7 @@ namespace int create_load_memory_address_file (dl_phdr_info * info, size_t, void *) { static int counter = 0; - assert (counter <= 99); + debug_assert (counter <= 99); // Create filename const char file_prefix[] = "nano_node_crash_load_address_dump_"; // Holds the filename prefix, a unique (max 2 digits) number and extension (null terminator is included in file_prefix size) @@ -30,7 +29,7 @@ int create_load_memory_address_file (dl_phdr_info * info, size_t, void *) 0 #endif ); - assert (file_descriptor); + debug_assert (file_descriptor); if (file_descriptor) { // Write the name of shared library (can be empty for the executable) diff --git a/nano/lib/plat/windows/perms.cpp b/nano/lib/plat/windows/perms.cpp index e2b188a903..1fc093b539 100644 --- a/nano/lib/plat/windows/perms.cpp +++ b/nano/lib/plat/windows/perms.cpp @@ -2,8 +2,6 @@ #include -#include - // clang-format off // Keep windows.h header at the top #include @@ -17,7 +15,7 @@ void nano::set_umask () int oldMode; auto result (_umask_s (_S_IWRITE | _S_IREAD, &oldMode)); - assert (result == 0); + debug_assert (result == 0); } void nano::set_secure_perm_directory (boost::filesystem::path const & path) diff --git a/nano/lib/stream.hpp b/nano/lib/stream.hpp index 190fc0f178..c5c537ae96 100644 --- a/nano/lib/stream.hpp +++ b/nano/lib/stream.hpp @@ -1,7 +1,7 @@ - #pragma once -#include +#include + #include namespace nano @@ -33,6 +33,6 @@ void write (nano::stream & stream_a, T const & value) static_assert (std::is_standard_layout::value, "Can't stream write non-standard layout types"); auto amount_written (stream_a.sputn (reinterpret_cast (&value), sizeof (value))); (void)amount_written; - assert (amount_written == sizeof (value)); + debug_assert (amount_written == sizeof (value)); } } diff --git a/nano/lib/threading.cpp b/nano/lib/threading.cpp index a996d35a5e..ed5b8222b7 100644 --- a/nano/lib/threading.cpp +++ b/nano/lib/threading.cpp @@ -80,7 +80,7 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) * length supported by the platforms we support * (specifically, Linux) */ - assert (thread_role_name_string.size () < 16); + debug_assert (thread_role_name_string.size () < 16); return (thread_role_name_string); } diff --git a/nano/lib/timer.cpp b/nano/lib/timer.cpp index d45bab4baa..ed2988a2f2 100644 --- a/nano/lib/timer.cpp +++ b/nano/lib/timer.cpp @@ -1,6 +1,6 @@ #include +#include -#include #include #include @@ -91,7 +91,7 @@ nano::timer & nano::timer::start_child (std::string co template void nano::timer::start () { - assert (state == nano::timer_state::stopped); + debug_assert (state == nano::timer_state::stopped); state = nano::timer_state::started; begin = CLOCK::now (); } @@ -115,7 +115,7 @@ UNIT nano::timer::pause () template UNIT nano::timer::stop () { - assert (state == nano::timer_state::started); + debug_assert (state == nano::timer_state::started); state = nano::timer_state::stopped; auto end = CLOCK::now (); diff --git a/nano/lib/tomlconfig.cpp b/nano/lib/tomlconfig.cpp index 1ee90e1c0c..42bc938627 100644 --- a/nano/lib/tomlconfig.cpp +++ b/nano/lib/tomlconfig.cpp @@ -299,7 +299,7 @@ nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string cons void nano::tomlconfig::erase_defaults (std::shared_ptr base, std::shared_ptr other, std::shared_ptr update_target) { std::vector erased; - assert (other != nullptr); + debug_assert (other != nullptr); for (auto & item : *other) { std::string const & key = item.first; diff --git a/nano/lib/utility.cpp b/nano/lib/utility.cpp index c02e853d0f..d62865a1f2 100644 --- a/nano/lib/utility.cpp +++ b/nano/lib/utility.cpp @@ -5,6 +5,7 @@ #include #include +#include // Some builds (mac) fail due to "Boost.Stacktrace requires `_Unwind_Backtrace` function". #ifndef _WIN32 @@ -105,20 +106,21 @@ void nano::move_all_files_to_dir (boost::filesystem::path const & from, boost::f } /* - * Backing code for "release_assert", which is itself a macro + * Backing code for "release_assert" & "debug_assert", which are macros */ -void release_assert_internal (bool check, const char * check_expr, const char * file, unsigned int line) +void assert_internal (const char * check_expr, const char * file, unsigned int line, bool is_release_assert) { - if (check) - { - return; - } - - std::cerr << "Assertion (" << check_expr << ") failed " << file << ":" << line << "\n\n"; - - // Output stack trace to cerr + // Output stack trace auto backtrace_str = nano::generate_stacktrace (); + // Windows on Actions only outputs the first line of the stacktrace from standard error, use standard output +#if (defined(_WIN32) && CI) + std::cout << backtrace_str << std::endl; +#else std::cerr << backtrace_str << std::endl; +#endif + + std::cerr << "Assertion (" << check_expr << ") failed " << file << ":" << line << "\n" + << std::endl; // "abort" at the end of this function will go into any signal handlers (the daemon ones will generate a stack trace and load memory address files on non-Windows systems). // As there is no async-signal-safe way to generate stacktraces on Windows it must be done before aborting @@ -127,7 +129,7 @@ void release_assert_internal (bool check, const char * check_expr, const char * // Try construct the stacktrace dump in the same folder as the the running executable, otherwise use the current directory. boost::system::error_code err; auto running_executable_filepath = boost::dll::program_location (err); - std::string filename = "nano_node_backtrace_release_assert.txt"; + std::string filename = is_release_assert ? "nano_node_backtrace_release_assert.txt" : "nano_node_backtrace_assert.txt"; std::string filepath = filename; if (!err) { @@ -139,5 +141,6 @@ void release_assert_internal (bool check, const char * check_expr, const char * file << backtrace_str; } #endif + abort (); } diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index debec4689f..b61450ddba 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -20,6 +20,15 @@ namespace system } } +void assert_internal (const char * check_expr, const char * file, unsigned int line, bool is_release_assert); +#define release_assert(check) check ? (void)0 : assert_internal (#check, __FILE__, __LINE__, true) + +#ifdef NDEBUG +#define debug_assert(check) (void)0 +#else +#define debug_assert(check) check ? (void)0 : assert_internal (#check, __FILE__, __LINE__, false) +#endif + namespace nano { /* These containers are used to collect information about sequence containers. @@ -168,10 +177,7 @@ template constexpr TARGET_TYPE narrow_cast (SOURCE_TYPE const & val) { auto res (static_cast (val)); - assert (val == static_cast (res)); + debug_assert (val == static_cast (res)); return res; } } - -void release_assert_internal (bool check, const char * check_expr, const char * file, unsigned int line); -#define release_assert(check) release_assert_internal (check, #check, __FILE__, __LINE__) diff --git a/nano/lib/walletconfig.cpp b/nano/lib/walletconfig.cpp index e3f91a6405..885bd54936 100644 --- a/nano/lib/walletconfig.cpp +++ b/nano/lib/walletconfig.cpp @@ -5,7 +5,7 @@ nano::wallet_config::wallet_config () { nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); - assert (!wallet.is_zero ()); + debug_assert (!wallet.is_zero ()); } nano::error nano::wallet_config::parse (std::string const & wallet_a, std::string const & account_a) diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 50640b85c8..61b9e80da1 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -35,7 +35,7 @@ bool nano::work_validate (nano::work_version const version_a, nano::root const & invalid = nano::work_v1::validate (root_a, work_a, difficulty_a); break; default: - assert (false && "Invalid version specified to work_validate"); + debug_assert (false && "Invalid version specified to work_validate"); } return invalid; } @@ -48,7 +48,7 @@ bool nano::work_validate (nano::block const & block_a, uint64_t * difficulty_a) bool nano::work_validate (nano::root const & root_a, uint64_t const work_a, uint64_t * difficulty_a) { static nano::network_constants network_constants; - assert (network_constants.is_test_network ()); + debug_assert (network_constants.is_test_network ()); return nano::work_validate (nano::work_version::work_1, root_a, work_a, difficulty_a); } @@ -80,7 +80,7 @@ uint64_t nano::work_v1::value (nano::root const & root_a, uint64_t work_a) static nano::network_constants network_constants; if (!network_constants.is_test_network ()) { - assert (false); + debug_assert (false); std::exit (1); } return network_constants.publish_threshold + 1; @@ -186,8 +186,8 @@ void nano::work_pool::loop (uint64_t thread) if (ticket == ticket_l) { // If the ticket matches what we started with, we're the ones that found the solution - assert (output >= current_l.difficulty); - assert (current_l.difficulty == 0 || nano::work_v1::value (current_l.item, work) == output); + debug_assert (output >= current_l.difficulty); + debug_assert (current_l.difficulty == 0 || nano::work_v1::value (current_l.item, work) == output); // Signal other threads to stop their work next time they check ticket ++ticket; pending.pop_front (); @@ -262,7 +262,7 @@ void nano::work_pool::generate (nano::root const & root_a, std::function const &)> callback_a, uint64_t difficulty_a) { - assert (!root_a.is_zero ()); + debug_assert (!root_a.is_zero ()); if (!threads.empty ()) { { @@ -280,7 +280,7 @@ void nano::work_pool::generate (nano::work_version const version_a, nano::root c boost::optional nano::work_pool::generate (nano::root const & root_a) { static nano::network_constants network_constants; - assert (network_constants.is_test_network ()); + debug_assert (network_constants.is_test_network ()); return generate (nano::work_version::work_1, root_a); } @@ -292,7 +292,7 @@ boost::optional nano::work_pool::generate (nano::work_version const ve boost::optional nano::work_pool::generate (nano::root const & root_a, uint64_t difficulty_a) { static nano::network_constants network_constants; - assert (network_constants.is_test_network ()); + debug_assert (network_constants.is_test_network ()); return generate (nano::work_version::work_1, root_a, difficulty_a); } diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index 3380b1f541..2d279c6e46 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -450,7 +450,7 @@ int main (int argc, char * const * argv) #else std::thread processes_thread ([&data_paths, &node_path, &rpc_path, ¤t_network]() { auto formatted_command = "%1% --daemon --data_path=%2% --network=%3% %4%"; - assert (!data_paths.empty ()); + ASSERT_TRUE (!data_paths.empty ()); for (int i = 0; i < data_paths.size (); ++i) { auto node_exe_command = boost::str (boost::format (formatted_command) % node_path % data_paths[i].string () % current_network % "&"); @@ -474,7 +474,7 @@ int main (int argc, char * const * argv) boost::asio::io_context ioc; - assert (!nano::signal_handler_impl); + debug_assert (!nano::signal_handler_impl); nano::signal_handler_impl = [&ioc]() { ioc.stop (); }; diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index cd93200c35..e7f3ae64bb 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -136,7 +136,7 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: } } - assert (!nano::signal_handler_impl); + debug_assert (!nano::signal_handler_impl); nano::signal_handler_impl = [&io_ctx]() { io_ctx.stop (); sig_int_or_term = 1; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index fe564243c9..eca4a1d0d8 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -203,7 +203,7 @@ int main (int argc, char * const * argv) auto weekly_distribution (yearly_distribution / 52); for (auto j (0); j != 52; ++j) { - assert (balance > weekly_distribution); + debug_assert (balance > weekly_distribution); balance = balance < (weekly_distribution * 2) ? 0 : balance - weekly_distribution; nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous)); previous = send.hash (); diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp index 4ce9b87511..f6e31b47bf 100644 --- a/nano/nano_rpc/entry.cpp +++ b/nano/nano_rpc/entry.cpp @@ -52,7 +52,7 @@ void run (boost::filesystem::path const & data_path, std::vector co auto rpc = nano::get_rpc (io_ctx, rpc_config, ipc_rpc_processor); rpc->start (); - assert (!nano::signal_handler_impl); + debug_assert (!nano::signal_handler_impl); nano::signal_handler_impl = [&io_ctx]() { io_ctx.stop (); sig_int_or_term = 1; diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 2528f68f9b..570d3904cb 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -143,7 +143,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost wallet_config.account = wallet->deterministic_insert (transaction); } } - assert (wallet->exists (wallet_config.account)); + debug_assert (wallet->exists (wallet_config.account)); write_wallet_config (wallet_config, data_path); node->start (); nano::ipc::ipc_server ipc (*node, config.rpc); diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 1e410075fd..57a0c257cc 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -38,8 +38,8 @@ thread ([this]() { this->cemented_batch_finished_callback (); }); - assert (min_time_between_requests > std::chrono::milliseconds (node.network_params.network.request_interval_ms)); - assert (min_time_between_floods > std::chrono::milliseconds (node.network_params.network.request_interval_ms)); + debug_assert (min_time_between_requests > std::chrono::milliseconds (node.network_params.network.request_interval_ms)); + debug_assert (min_time_between_floods > std::chrono::milliseconds (node.network_params.network.request_interval_ms)); nano::unique_lock lock (mutex); condition.wait (lock, [& started = started] { return started; }); } @@ -259,7 +259,7 @@ void nano::active_transactions::election_escalate (std::shared_ptr & lock_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); auto transaction_l (node.store.tx_begin_read ()); std::unordered_set inactive_l; /* @@ -410,7 +410,7 @@ void nano::active_transactions::prioritize_account_for_confirmation (nano::activ } else { - assert (cementable_frontiers_size_a <= max_priority_cementable_frontiers); + debug_assert (cementable_frontiers_size_a <= max_priority_cementable_frontiers); if (cementable_frontiers_size_a == max_priority_cementable_frontiers) { // The maximum amount of frontiers stored has been reached. Check if the current frontier @@ -681,7 +681,7 @@ void nano::active_transactions::update_difficulty (std::shared_ptr uint64_t difficulty; auto error (nano::work_validate (nano::work_version::work_1, *block_a, &difficulty)); (void)error; - assert (!error); + debug_assert (!error); if (difficulty > existing_election->difficulty) { if (node.config.logging.active_update_logging ()) @@ -734,7 +734,7 @@ void nano::active_transactions::update_difficulty (std::shared_ptr void nano::active_transactions::adjust_difficulty (nano::block_hash const & hash_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); std::deque> remaining_blocks; remaining_blocks.emplace_back (hash_a, 0); std::unordered_set processed_blocks; @@ -801,13 +801,13 @@ void nano::active_transactions::adjust_difficulty (nano::block_hash const & hash { // Highest adjusted difficulty value should be std::numeric_limits::max () limiter = std::numeric_limits::max () - average + highest_level; - assert (std::numeric_limits::max () == average + highest_level - limiter); + debug_assert (std::numeric_limits::max () == average + highest_level - limiter); } else if (average < std::numeric_limits::min () - lowest_level) { // Lowest adjusted difficulty value should be std::numeric_limits::min () limiter = std::numeric_limits::min () - average + lowest_level; - assert (std::numeric_limits::min () == average + lowest_level - limiter); + debug_assert (std::numeric_limits::min () == average + lowest_level - limiter); } // Set adjusted difficulty @@ -824,7 +824,7 @@ void nano::active_transactions::adjust_difficulty (nano::block_hash const & hash void nano::active_transactions::update_active_difficulty (nano::unique_lock & lock_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); double multiplier (1.); if (!roots.empty ()) { @@ -845,11 +845,11 @@ void nano::active_transactions::update_active_difficulty (nano::unique_lock= 1); + debug_assert (multiplier >= 1); multipliers_cb.push_front (multiplier); auto sum (std::accumulate (multipliers_cb.begin (), multipliers_cb.end (), double(0))); auto difficulty = nano::difficulty::from_multiplier (sum / multipliers_cb.size (), node.network_params.network.publish_threshold); - assert (difficulty >= node.network_params.network.publish_threshold); + debug_assert (difficulty >= node.network_params.network.publish_threshold); trended_active_difficulty = difficulty; node.observers.difficulty.notify (trended_active_difficulty); @@ -1116,7 +1116,7 @@ size_t nano::active_transactions::dropped_elections_cache_size () void nano::active_transactions::add_dropped_elections_cache (nano::qualified_root const & root_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); dropped_elections_cache.get ().emplace_back (nano::election_timepoint{ std::chrono::steady_clock::now (), root_a }); if (dropped_elections_cache.size () > dropped_elections_cache_max) { @@ -1126,7 +1126,7 @@ void nano::active_transactions::add_dropped_elections_cache (nano::qualified_roo std::chrono::steady_clock::time_point nano::active_transactions::find_dropped_elections_cache (nano::qualified_root const & root_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); auto existing (dropped_elections_cache.get ().find (root_a)); if (existing != dropped_elections_cache.get ().end ()) { diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index c9aba8448a..37fe2a11c7 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -5,8 +5,6 @@ #include -#include - std::chrono::milliseconds constexpr nano::block_processor::confirmation_request_delay; nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) : @@ -93,7 +91,7 @@ void nano::block_processor::add (nano::unchecked_info const & info_a) else { node.logger.try_log ("nano::block_processor::add called for hash ", info_a.block->hash ().to_string (), " with invalid work ", nano::to_string_hex (info_a.block->block_work ())); - assert (false && "nano::block_processor::add called with invalid work"); + debug_assert (false && "nano::block_processor::add called with invalid work"); } } @@ -147,13 +145,13 @@ bool nano::block_processor::should_log (bool first_time) bool nano::block_processor::have_blocks () { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); return !blocks.empty () || !forced.empty () || !state_blocks.empty (); } void nano::block_processor::verify_state_blocks (nano::unique_lock & lock_a, size_t max_count) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); nano::timer timer_l (nano::timer_state::started); std::deque items; if (state_blocks.size () <= max_count) @@ -167,7 +165,7 @@ void nano::block_processor::verify_state_blocks (nano::unique_lock & items.push_back (state_blocks.front ()); state_blocks.pop_front (); } - assert (!state_blocks.empty ()); + debug_assert (!state_blocks.empty ()); } lock_a.unlock (); if (!items.empty ()) @@ -214,7 +212,7 @@ void nano::block_processor::verify_state_blocks (nano::unique_lock & lock_a.lock (); for (auto i (0); i < size; ++i) { - assert (verifications[i] == 1 || verifications[i] == 0); + debug_assert (verifications[i] == 1 || verifications[i] == 0); auto & item (items.front ()); if (!item.block->link ().is_zero () && node.ledger.is_epoch_link (item.block->link ())) { @@ -556,7 +554,7 @@ void nano::block_processor::queue_unchecked (nano::write_transaction const & tra { if (!node.store.unchecked_del (transaction_a, nano::unchecked_key (hash_a, info.block->hash ()))) { - assert (node.ledger.cache.unchecked_count > 0); + debug_assert (node.ledger.cache.unchecked_count > 0); --node.ledger.cache.unchecked_count; } } @@ -580,7 +578,7 @@ nano::block_hash nano::block_processor::filter_item (nano::block_hash const & ha void nano::block_processor::requeue_invalid (nano::block_hash const & hash_a, nano::unchecked_info const & info_a) { - assert (hash_a == info_a.block->hash ()); + debug_assert (hash_a == info_a.block->hash ()); auto attempt (node.bootstrap_initiator.current_attempt ()); if (attempt != nullptr && attempt->mode == nano::bootstrap_mode::lazy) { diff --git a/nano/node/bootstrap/bootstrap.cpp b/nano/node/bootstrap/bootstrap.cpp index ca2a0ac4c2..ab1f56f20c 100644 --- a/nano/node/bootstrap/bootstrap.cpp +++ b/nano/node/bootstrap/bootstrap.cpp @@ -217,7 +217,7 @@ void nano::bootstrap_attempt::request_push (nano::unique_lock & lock bool nano::bootstrap_attempt::still_pulling () { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); auto running (!stopped); auto more_pulls (!pulls.empty ()); auto still_pulling (pulling > 0); @@ -254,7 +254,7 @@ void nano::bootstrap_attempt::run_start (nano::unique_lock & lock_a) void nano::bootstrap_attempt::run () { - assert (!node->flags.disable_legacy_bootstrap); + debug_assert (!node->flags.disable_legacy_bootstrap); start_populate_connections (); nano::unique_lock lock (mutex); run_start (lock); @@ -612,7 +612,7 @@ void nano::bootstrap_attempt::requeue_pull (nano::pull_info const & pull_a, bool } else if (mode == nano::bootstrap_mode::lazy && (pull.retry_limit == std::numeric_limits::max () || pull.attempts <= pull.retry_limit + (pull.processed / node->network_params.bootstrap.lazy_max_pull_blocks))) { - assert (pull.account_or_head == pull.head); + debug_assert (pull.account_or_head == pull.head); if (!lazy_processed_or_exists (pull.account_or_head)) { // Retry for lazy pulls @@ -632,7 +632,7 @@ void nano::bootstrap_attempt::requeue_pull (nano::pull_info const & pull_a, bool node->bootstrap_initiator.cache.add (pull); if (mode == nano::bootstrap_mode::lazy && pull.processed > 0) { - assert (pull.account_or_head == pull.head); + debug_assert (pull.account_or_head == pull.head); nano::lock_guard lazy_lock (lazy_mutex); lazy_add (pull.account_or_head, pull.retry_limit); } @@ -654,7 +654,7 @@ void nano::bootstrap_attempt::attempt_restart_check (nano::unique_lock (!node->network_params.network.is_test_network () ? nano::bootstrap_limits::requeued_pulls_limit : nano::bootstrap_limits::requeued_pulls_limit_test) || total_blocks > nano::bootstrap_limits::frontier_confirmation_blocks_limit)) { auto confirmed (confirm_frontiers (lock_a)); - assert (lock_a.owns_lock ()); + debug_assert (lock_a.owns_lock ()); if (!confirmed) { node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_confirmation_failed, nano::stat::dir::in); @@ -683,7 +683,7 @@ void nano::bootstrap_attempt::attempt_restart_check (nano::unique_lock & lock_a) { bool confirmed (false); - assert (!frontiers_confirmed); + debug_assert (!frontiers_confirmed); condition.wait (lock_a, [& stopped = stopped] { return !stopped; }); std::vector frontiers; for (auto i (pulls.begin ()), end (pulls.end ()); i != end && frontiers.size () != nano::bootstrap_limits::bootstrap_max_confirm_frontiers; ++i) @@ -842,7 +842,7 @@ void nano::bootstrap_attempt::lazy_start (nano::hash_or_account const & hash_or_ void nano::bootstrap_attempt::lazy_add (nano::hash_or_account const & hash_or_account_a, unsigned retry_limit) { // Add only unknown blocks - assert (!lazy_mutex.try_lock ()); + debug_assert (!lazy_mutex.try_lock ()); if (lazy_blocks.find (hash_or_account_a) == lazy_blocks.end ()) { lazy_pulls.emplace_back (hash_or_account_a, retry_limit); @@ -864,13 +864,13 @@ void nano::bootstrap_attempt::lazy_requeue (nano::block_hash const & hash_a, nan void nano::bootstrap_attempt::lazy_pull_flush () { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); static size_t const max_pulls (nano::bootstrap_limits::bootstrap_connection_scale_target_blocks_lazy * 3); if (pulls.size () < max_pulls) { last_lazy_flush = std::chrono::steady_clock::now (); nano::lock_guard lazy_lock (lazy_mutex); - assert (node->network_params.bootstrap.lazy_max_pull_blocks <= std::numeric_limits::max ()); + debug_assert (node->network_params.bootstrap.lazy_max_pull_blocks <= std::numeric_limits::max ()); nano::pull_info::count_t batch_count (node->network_params.bootstrap.lazy_max_pull_blocks); if (total_blocks > nano::bootstrap_limits::lazy_batch_pull_count_resize_blocks_limit && !lazy_blocks.empty ()) { @@ -968,7 +968,7 @@ bool nano::bootstrap_attempt::lazy_has_expired () const void nano::bootstrap_attempt::lazy_clear () { - assert (!lazy_mutex.try_lock ()); + debug_assert (!lazy_mutex.try_lock ()); lazy_blocks.clear (); lazy_blocks_count = 0; lazy_keys.clear (); @@ -980,7 +980,7 @@ void nano::bootstrap_attempt::lazy_clear () void nano::bootstrap_attempt::lazy_run () { - assert (!node->flags.disable_lazy_bootstrap); + debug_assert (!node->flags.disable_lazy_bootstrap); start_populate_connections (); lazy_start_time = std::chrono::steady_clock::now (); nano::unique_lock lock (mutex); @@ -1335,7 +1335,7 @@ void nano::bootstrap_attempt::wallet_start (std::deque & accounts bool nano::bootstrap_attempt::wallet_finished () { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); auto running (!stopped); auto more_accounts (!wallet_accounts.empty ()); auto still_pulling (pulling > 0); @@ -1344,7 +1344,7 @@ bool nano::bootstrap_attempt::wallet_finished () void nano::bootstrap_attempt::wallet_run () { - assert (!node->flags.disable_wallet_bootstrap); + debug_assert (!node->flags.disable_wallet_bootstrap); start_populate_connections (); auto start_time (std::chrono::steady_clock::now ()); auto max_time (std::chrono::minutes (10)); @@ -1594,7 +1594,7 @@ void nano::pulls_cache::add (nano::pull_info const & pull_a) { cache.erase (cache.begin ()); } - assert (cache.size () <= cache_size_max); + debug_assert (cache.size () <= cache_size_max); nano::uint512_union head_512 (pull_a.account_or_head, pull_a.head_original); auto existing (cache.get ().find (head_512)); if (existing == cache.get ().end ()) @@ -1602,7 +1602,7 @@ void nano::pulls_cache::add (nano::pull_info const & pull_a) // Insert new pull auto inserted (cache.emplace (nano::cached_pulls{ std::chrono::steady_clock::now (), head_512, pull_a.head })); (void)inserted; - assert (inserted.second); + debug_assert (inserted.second); } else { @@ -1642,14 +1642,14 @@ uint64_t nano::bootstrap_excluded_peers::add (nano::tcp_endpoint const & endpoin { peers.erase (peers.begin ()); } - assert (peers.size () <= excluded_peers_size_max); + debug_assert (peers.size () <= excluded_peers_size_max); auto existing (peers.get ().find (endpoint_a)); if (existing == peers.get ().end ()) { // Insert new endpoint auto inserted (peers.emplace (nano::excluded_peers_item{ std::chrono::steady_clock::steady_clock::now () + exclude_time_hours, endpoint_a, 1 })); (void)inserted; - assert (inserted.second); + debug_assert (inserted.second); result = 1; } else diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 0a8a21c663..f8c8a16a9b 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -55,7 +55,7 @@ nano::bulk_pull_client::~bulk_pull_client () void nano::bulk_pull_client::request () { - assert (!pull.head.is_zero () || pull.retry_limit != std::numeric_limits::max ()); + debug_assert (!pull.head.is_zero () || pull.retry_limit != std::numeric_limits::max ()); expected = pull.head; nano::bulk_pull req; if (pull.head == pull.head_original && pull.attempts % 4 < 3) @@ -103,7 +103,7 @@ void nano::bulk_pull_client::request () void nano::bulk_pull_client::throttled_receive_block () { - assert (!network_error); + debug_assert (!network_error); if (!connection->node->block_processor.half_full ()) { receive_block (); @@ -352,12 +352,12 @@ void nano::bulk_pull_account_client::receive_pending () nano::bufferstream frontier_stream (this_l->connection->receive_buffer->data (), sizeof (nano::uint256_union)); auto error1 (nano::try_read (frontier_stream, pending)); (void)error1; - assert (!error1); + debug_assert (!error1); nano::amount balance; nano::bufferstream balance_stream (this_l->connection->receive_buffer->data () + sizeof (nano::uint256_union), sizeof (nano::uint128_union)); auto error2 (nano::try_read (balance_stream, balance)); (void)error2; - assert (!error2); + debug_assert (!error2); if (this_l->pull_blocks == 0 || !pending.is_zero ()) { if (this_l->pull_blocks == 0 || balance.number () >= this_l->connection->node->config.receive_minimum.number ()) @@ -423,7 +423,7 @@ void nano::bulk_pull_account_client::receive_pending () void nano::bulk_pull_server::set_current_end () { include_start = false; - assert (request != nullptr); + debug_assert (request != nullptr); auto transaction (connection->node->store.tx_begin_read ()); if (!connection->node->store.block_exists (transaction, request->end)) { @@ -613,7 +613,7 @@ void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec { if (!ec) { - assert (size_a == 1); + debug_assert (size_a == 1); connection->finish_request (); } else @@ -637,7 +637,7 @@ request (std::move (request_a)) */ void nano::bulk_pull_account_server::set_params () { - assert (request != nullptr); + debug_assert (request != nullptr); /* * Parse the flags @@ -920,17 +920,17 @@ void nano::bulk_pull_account_server::complete (boost::system::error_code const & { if (pending_address_only) { - assert (size_a == 32); + debug_assert (size_a == 32); } else { if (pending_include_address) { - assert (size_a == 80); + debug_assert (size_a == 80); } else { - assert (size_a == 48); + debug_assert (size_a == 48); } } diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 317fd5c959..1456451287 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -92,17 +92,17 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con { if (!ec) { - assert (size_a == nano::frontier_req_client::size_frontier); + debug_assert (size_a == nano::frontier_req_client::size_frontier); nano::account account; nano::bufferstream account_stream (connection->receive_buffer->data (), sizeof (account)); auto error1 (nano::try_read (account_stream, account)); (void)error1; - assert (!error1); + debug_assert (!error1); nano::block_hash latest; nano::bufferstream latest_stream (connection->receive_buffer->data () + sizeof (account), sizeof (latest)); auto error2 (nano::try_read (latest_stream, latest)); (void)error2; - assert (!error2); + debug_assert (!error2); if (count == 0) { start_time = std::chrono::steady_clock::now (); @@ -157,7 +157,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con } else { - assert (account < current); + debug_assert (account < current); connection->attempt->add_pull (nano::pull_info (account, latest, nano::block_hash (0), 0, connection->node->network_params.bootstrap.frontier_retry_limit)); } } diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index f3de55dccc..e8c9cc1168 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -24,7 +24,7 @@ void nano::bootstrap_listener::start () node.logger.try_log (boost::str (boost::format ("Error while binding for incoming TCP/bootstrap on port %1%: %2%") % listening_socket->listening_port () % ec.message ())); throw std::runtime_error (ec.message ()); } - 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 new_connection, boost::system::error_code const & ec_a) { bool keep_accepting = true; if (ec_a) @@ -160,7 +160,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co { if (!ec) { - assert (size_a == 8); + debug_assert (size_a == 8); nano::bufferstream type_stream (receive_buffer->data (), size_a); auto error (false); nano::message_header header (error, type_stream); @@ -307,7 +307,7 @@ void nano::bootstrap_server::receive_bulk_pull_account_action (boost::system::er if (!ec) { auto error (false); - assert (size_a == header_a.payload_length_bytes ()); + debug_assert (size_a == header_a.payload_length_bytes ()); nano::bufferstream stream (receive_buffer->data (), size_a); auto request (std::make_unique (error, stream, header_a)); if (!error) @@ -497,7 +497,7 @@ void nano::bootstrap_server::receive_node_id_handshake_action (boost::system::er void nano::bootstrap_server::add_request (std::unique_ptr message_a) { - assert (message_a != nullptr); + debug_assert (message_a != nullptr); nano::lock_guard lock (mutex); auto start (requests.empty ()); requests.push (std::move (message_a)); @@ -648,7 +648,7 @@ class request_response_visitor : public nano::message_visitor if (message_a.query) { boost::optional> response (std::make_pair (connection->node->node_id.pub, nano::sign_message (connection->node->node_id.prv, connection->node->node_id.pub, *message_a.query))); - assert (!nano::validate_message (response->first, *message_a.query, response->second)); + debug_assert (!nano::validate_message (response->first, *message_a.query, response->second)); 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); auto shared_const_buffer = response_message.to_shared_const_buffer (); @@ -694,7 +694,7 @@ class request_response_visitor : public nano::message_visitor } nano::account node_id (connection->remote_node_id); nano::bootstrap_server_type type (connection->type); - assert (node_id.is_zero () || type == nano::bootstrap_server_type::realtime); + debug_assert (node_id.is_zero () || type == nano::bootstrap_server_type::realtime); auto connection_l (connection->shared_from_this ()); connection->node->background ([connection_l, message_a, node_id, type]() { connection_l->node->network.tcp_channels.process_message (message_a, connection_l->remote_endpoint, node_id, connection_l->socket, type); @@ -706,7 +706,7 @@ class request_response_visitor : public nano::message_visitor void nano::bootstrap_server::run_next () { - assert (!requests.empty ()); + debug_assert (!requests.empty ()); request_response_visitor visitor (shared_from_this ()); requests.front ()->visit (visitor); } diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 6782216eee..c7cc0f751f 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -836,7 +836,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map nano::raw_key key; auto error (existing->second->store.fetch (transaction, account, key)); (void)error; - assert (!error); + debug_assert (!error); std::cout << boost::str (boost::format ("Pub: %1% Prv: %2%\n") % account.to_account () % key.data.to_string ()); if (nano::pub_key (key.as_private_key ()) != account) { diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 3628d511d6..1856b8de2c 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -31,7 +31,7 @@ nano::protocol_constants const & get_protocol_constants () uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint16_t port) { static nano::random_constants constants; - assert (ip_a.is_v6 ()); + debug_assert (ip_a.is_v6 ()); uint64_t result; nano::uint128_union address; address.bytes = ip_a.to_v6 ().to_bytes (); @@ -144,7 +144,7 @@ uint8_t nano::message_header::count_get () const void nano::message_header::count_set (uint8_t count_a) { - assert (count_a < 16); + debug_assert (count_a < 16); extensions &= ~count_mask; extensions |= std::bitset<16> (static_cast (count_a) << 12); } @@ -152,7 +152,7 @@ void nano::message_header::count_set (uint8_t count_a) void nano::message_header::flag_set (uint8_t flag_a) { // Flags from 8 are block_type & count - assert (flag_a < 8); + debug_assert (flag_a < 8); extensions.set (flag_a, true); } @@ -243,7 +243,7 @@ size_t nano::message_header::payload_length_bytes () const } default: { - assert (false); + debug_assert (false); return 0; } } @@ -314,7 +314,7 @@ std::string nano::message_parser::status_string () } } - assert (false); + debug_assert (false); return "[unknown parse_status]"; } @@ -561,7 +561,7 @@ void nano::keepalive::serialize (nano::stream & stream_a) const header.serialize (stream_a); for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i) { - assert (i->address ().is_v6 ()); + debug_assert (i->address ().is_v6 ()); auto bytes (i->address ().to_v6 ().to_bytes ()); write (stream_a, bytes); write (stream_a, i->port ()); @@ -570,7 +570,7 @@ void nano::keepalive::serialize (nano::stream & stream_a) const bool nano::keepalive::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::keepalive); + debug_assert (header.type == nano::message_type::keepalive); auto error (false); for (auto i (peers.begin ()), j (peers.end ()); i != j && !error; ++i) { @@ -611,14 +611,14 @@ block (block_a) void nano::publish::serialize (nano::stream & stream_a) const { - assert (block != nullptr); + debug_assert (block != nullptr); header.serialize (stream_a); block->serialize (stream_a); } bool nano::publish::deserialize (nano::stream & stream_a, nano::block_uniquer * uniquer_a) { - assert (header.type == nano::message_type::publish); + debug_assert (header.type == nano::message_type::publish); block = nano::deserialize_block (stream_a, header.block_type (), uniquer_a); auto result (block == nullptr); return result; @@ -656,7 +656,7 @@ roots_hashes (roots_hashes_a) { // not_a_block (1) block type for hashes + roots request header.block_type_set (nano::block_type::not_a_block); - assert (roots_hashes.size () < 16); + debug_assert (roots_hashes.size () < 16); header.count_set (static_cast (roots_hashes.size ())); } @@ -664,10 +664,10 @@ nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root cons message (nano::message_type::confirm_req), roots_hashes (std::vector> (1, std::make_pair (hash_a, root_a))) { - assert (!roots_hashes.empty ()); + debug_assert (!roots_hashes.empty ()); // not_a_block (1) block type for hashes + roots request header.block_type_set (nano::block_type::not_a_block); - assert (roots_hashes.size () < 16); + debug_assert (roots_hashes.size () < 16); header.count_set (static_cast (roots_hashes.size ())); } @@ -681,7 +681,7 @@ void nano::confirm_req::serialize (nano::stream & stream_a) const header.serialize (stream_a); if (header.block_type () == nano::block_type::not_a_block) { - assert (!roots_hashes.empty ()); + debug_assert (!roots_hashes.empty ()); // Write hashes & roots for (auto & root_hash : roots_hashes) { @@ -691,7 +691,7 @@ void nano::confirm_req::serialize (nano::stream & stream_a) const } else { - assert (block != nullptr); + debug_assert (block != nullptr); block->serialize (stream_a); } } @@ -699,7 +699,7 @@ void nano::confirm_req::serialize (nano::stream & stream_a) const bool nano::confirm_req::deserialize (nano::stream & stream_a, nano::block_uniquer * uniquer_a) { bool result (false); - assert (header.type == nano::message_type::confirm_req); + debug_assert (header.type == nano::message_type::confirm_req); try { if (header.block_type () == nano::block_type::not_a_block) @@ -788,12 +788,12 @@ nano::confirm_ack::confirm_ack (std::shared_ptr vote_a) : message (nano::message_type::confirm_ack), vote (vote_a) { - assert (!vote_a->blocks.empty ()); + debug_assert (!vote_a->blocks.empty ()); auto & first_vote_block (vote_a->blocks[0]); if (first_vote_block.which ()) { header.block_type_set (nano::block_type::not_a_block); - assert (vote_a->blocks.size () < 16); + debug_assert (vote_a->blocks.size () < 16); header.count_set (static_cast (vote_a->blocks.size ())); } else @@ -804,7 +804,7 @@ vote (vote_a) void nano::confirm_ack::serialize (nano::stream & stream_a) const { - assert (header.block_type () == nano::block_type::not_a_block || header.block_type () == nano::block_type::send || header.block_type () == nano::block_type::receive || header.block_type () == nano::block_type::open || header.block_type () == nano::block_type::change || header.block_type () == nano::block_type::state); + debug_assert (header.block_type () == nano::block_type::not_a_block || header.block_type () == nano::block_type::send || header.block_type () == nano::block_type::receive || header.block_type () == nano::block_type::open || header.block_type () == nano::block_type::change || header.block_type () == nano::block_type::state); header.serialize (stream_a); vote->serialize (stream_a, header.block_type ()); } @@ -858,7 +858,7 @@ void nano::frontier_req::serialize (nano::stream & stream_a) const bool nano::frontier_req::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::frontier_req); + debug_assert (header.type == nano::message_type::frontier_req); auto error (false); try { @@ -913,7 +913,7 @@ void nano::bulk_pull::serialize (nano::stream & stream_a) const * and that is the behavior of not having the flag set * so it is wasteful to do this. */ - assert ((count == 0 && !is_count_present ()) || (count != 0 && is_count_present ())); + debug_assert ((count == 0 && !is_count_present ()) || (count != 0 && is_count_present ())); header.serialize (stream_a); write (stream_a, start); @@ -934,7 +934,7 @@ void nano::bulk_pull::serialize (nano::stream & stream_a) const bool nano::bulk_pull::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::bulk_pull); + debug_assert (header.type == nano::message_type::bulk_pull); auto error (false); try { @@ -1009,7 +1009,7 @@ void nano::bulk_pull_account::serialize (nano::stream & stream_a) const bool nano::bulk_pull_account::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::bulk_pull_account); + debug_assert (header.type == nano::message_type::bulk_pull_account); auto error (false); try { @@ -1037,7 +1037,7 @@ message (header_a) bool nano::bulk_push::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::bulk_push); + debug_assert (header.type == nano::message_type::bulk_push); return false; } @@ -1063,7 +1063,7 @@ message (header_a) bool nano::telemetry_req::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::telemetry_req); + debug_assert (header.type == nano::message_type::telemetry_req); return false; } @@ -1117,13 +1117,14 @@ void nano::telemetry_ack::serialize (nano::stream & stream_a) const write (stream_a, *data.patch_version); write (stream_a, *data.pre_release_version); write (stream_a, *data.maker); + write (stream_a, std::chrono::duration_cast (data.timestamp->time_since_epoch ()).count ()); } } bool nano::telemetry_ack::deserialize (nano::stream & stream_a) { auto error (false); - assert (header.type == nano::message_type::telemetry_ack); + debug_assert (header.type == nano::message_type::telemetry_ack); try { if (!is_empty_payload ()) @@ -1151,6 +1152,13 @@ bool nano::telemetry_ack::deserialize (nano::stream & stream_a) read (stream_a, out); data.maker = out; } + + if (header.extensions.to_ulong () > telemetry_data::size_v1) + { + uint64_t timestamp; + read (stream_a, timestamp); + data.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (timestamp)); + } } } catch (std::runtime_error const &) @@ -1209,6 +1217,10 @@ nano::error nano::telemetry_data::serialize_json (nano::jsonconfig & json) const { json.put ("maker", *maker); } + if (timestamp.is_initialized ()) + { + json.put ("timestamp", std::chrono::duration_cast (timestamp->time_since_epoch ()).count ()); + } return json.get_error (); } @@ -1236,13 +1248,18 @@ nano::error nano::telemetry_data::deserialize_json (nano::jsonconfig & json) patch_version = json.get_optional ("patch_version"); pre_release_version = json.get_optional ("pre_release_version"); maker = json.get_optional ("maker"); + auto timestamp_l = json.get_optional ("timestamp"); + if (timestamp_l.is_initialized ()) + { + timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (*timestamp_l)); + } return json.get_error (); } bool nano::telemetry_data::operator== (nano::telemetry_data const & data_a) const { - return (block_count == data_a.block_count && cemented_count == data_a.cemented_count && unchecked_count == data_a.unchecked_count && account_count == data_a.account_count && bandwidth_cap == data_a.bandwidth_cap && uptime == data_a.uptime && peer_count == data_a.peer_count && protocol_version == data_a.protocol_version && genesis_block == data_a.genesis_block && major_version == data_a.major_version && minor_version == data_a.minor_version && patch_version == data_a.patch_version && pre_release_version == data_a.pre_release_version && maker == data_a.maker); + return (block_count == data_a.block_count && cemented_count == data_a.cemented_count && unchecked_count == data_a.unchecked_count && account_count == data_a.account_count && bandwidth_cap == data_a.bandwidth_cap && uptime == data_a.uptime && peer_count == data_a.peer_count && protocol_version == data_a.protocol_version && genesis_block == data_a.genesis_block && major_version == data_a.major_version && minor_version == data_a.minor_version && patch_version == data_a.patch_version && pre_release_version == data_a.pre_release_version && maker == data_a.maker && timestamp == data_a.timestamp); } bool nano::telemetry_data::operator!= (nano::telemetry_data const & data_a) const @@ -1289,7 +1306,7 @@ void nano::node_id_handshake::serialize (nano::stream & stream_a) const bool nano::node_id_handshake::deserialize (nano::stream & stream_a) { - assert (header.type == nano::message_type::node_id_handshake); + debug_assert (header.type == nano::message_type::node_id_handshake); auto error (false); try { @@ -1368,7 +1385,6 @@ bool nano::parse_port (std::string const & string_a, uint16_t & port_a) // Can handle both ipv4 & ipv6 addresses (with and without square brackets) bool nano::parse_address (std::string const & address_text_a, boost::asio::ip::address & address_a) { - auto result (false); auto address_text = address_text_a; if (!address_text.empty () && address_text.front () == '[' && address_text.back () == ']') { diff --git a/nano/node/common.hpp b/nano/node/common.hpp index 9464ba803c..4cf7273208 100644 --- a/nano/node/common.hpp +++ b/nano/node/common.hpp @@ -349,6 +349,7 @@ class telemetry_data boost::optional patch_version; boost::optional pre_release_version; boost::optional maker; // 0 for NF node + boost::optional timestamp; nano::error serialize_json (nano::jsonconfig & json) const; nano::error deserialize_json (nano::jsonconfig & json); @@ -356,7 +357,8 @@ class telemetry_data bool operator!= (nano::telemetry_data const &) const; static auto constexpr size_v0 = sizeof (block_count) + sizeof (cemented_count) + sizeof (unchecked_count) + sizeof (account_count) + sizeof (bandwidth_cap) + sizeof (peer_count) + sizeof (protocol_version) + sizeof (uptime) + sizeof (genesis_block) + sizeof (major_version); - static auto constexpr size = size_v0 + sizeof (decltype (minor_version)::value_type) + sizeof (decltype (patch_version)::value_type) + sizeof (decltype (pre_release_version)::value_type) + sizeof (decltype (maker)::value_type); + static auto constexpr size_v1 = size_v0 + sizeof (decltype (minor_version)::value_type) + sizeof (decltype (patch_version)::value_type) + sizeof (decltype (pre_release_version)::value_type) + sizeof (decltype (maker)::value_type); + static auto constexpr size = size_v1 + sizeof (uint64_t); }; class telemetry_req final : public message { diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 0db45d04e0..4b543fd345 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -67,7 +67,7 @@ void nano::confirmation_height_bounded::process () auto top_level_hash = current; nano::block_sideband sideband; auto block = ledger.store.block_get (transaction, current, &sideband); - assert (block != nullptr); + debug_assert (block != nullptr); nano::account account (block->account ()); if (account.is_zero ()) { @@ -85,7 +85,7 @@ void nano::confirmation_height_bounded::process () else { auto error = ledger.store.confirmation_height_get (transaction, account, confirmation_height_info); - assert (!error); + debug_assert (!error); } auto block_height = sideband.height; @@ -184,7 +184,7 @@ void nano::confirmation_height_bounded::process () transaction.refresh (); } while ((!receive_source_pairs.empty () || current != original_hash) && !stopped); - assert (checkpoints.empty ()); + debug_assert (checkpoints.empty ()); } nano::block_hash nano::confirmation_height_bounded::get_least_unconfirmed_hash_from_top_level (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a, uint64_t & block_height_a) @@ -344,10 +344,10 @@ bool nano::confirmation_height_bounded::cement_blocks () #ifndef NDEBUG // Extra debug checks nano::confirmation_height_info confirmation_height_info; - assert (!ledger.store.confirmation_height_get (transaction, account, confirmation_height_info)); + debug_assert (!ledger.store.confirmation_height_get (transaction, account, confirmation_height_info)); nano::block_sideband sideband; - assert (ledger.store.block_get (transaction, confirmed_frontier, &sideband)); - assert (sideband.height == confirmation_height_info.height + num_blocks_cemented); + debug_assert (ledger.store.block_get (transaction, confirmed_frontier, &sideband)); + debug_assert (sideband.height == confirmation_height_info.height + num_blocks_cemented); #endif ledger.store.confirmation_height_put (transaction, account, nano::confirmation_height_info{ confirmation_height, confirmed_frontier }); ledger.cache.cemented_count += num_blocks_cemented; @@ -370,7 +370,7 @@ bool nano::confirmation_height_bounded::cement_blocks () { new_cemented_frontier = pending.bottom_hash; // If we are higher than the cemented frontier, we should be exactly 1 block above - assert (pending.bottom_height == confirmation_height_info.height + 1); + debug_assert (pending.bottom_height == confirmation_height_info.height + 1); num_blocks_confirmed = pending.top_height - pending.bottom_height + 1; start_height = pending.bottom_height; } @@ -424,7 +424,7 @@ bool nano::confirmation_height_bounded::cement_blocks () else { // Confirm it is indeed the last one - assert (new_cemented_frontier == pending.top_hash); + debug_assert (new_cemented_frontier == pending.top_hash); } } @@ -445,8 +445,8 @@ bool nano::confirmation_height_bounded::cement_blocks () notify_observers_callback (cemented_blocks); - assert (pending_writes.empty ()); - assert (pending_writes_size == 0); + debug_assert (pending_writes.empty ()); + debug_assert (pending_writes_size == 0); return false; } diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index 9a5ecce3a5..e65698ed89 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -9,7 +9,6 @@ #include -#include #include 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::logger_mt & logger_a, boost::latch & latch, confirmation_height_mode mode_a) : @@ -66,7 +65,7 @@ void nano::confirmation_height_processor::run (confirmation_height_mode mode_a) // Don't want to mix up pending writes across different processors if (mode_a == confirmation_height_mode::unbounded || (mode_a == confirmation_height_mode::automatic && blocks_within_automatic_unbounded_selection && confirmation_height_bounded_processor.pending_empty ())) { - assert (confirmation_height_bounded_processor.pending_empty ()); + debug_assert (confirmation_height_bounded_processor.pending_empty ()); if (confirmation_height_unbounded_processor.pending_empty ()) { confirmation_height_unbounded_processor.prepare_new (); @@ -75,8 +74,8 @@ void nano::confirmation_height_processor::run (confirmation_height_mode mode_a) } else { - assert (mode_a == confirmation_height_mode::bounded || mode_a == confirmation_height_mode::automatic); - assert (confirmation_height_unbounded_processor.pending_empty ()); + debug_assert (mode_a == confirmation_height_mode::bounded || mode_a == confirmation_height_mode::automatic); + debug_assert (confirmation_height_unbounded_processor.pending_empty ()); if (confirmation_height_bounded_processor.pending_empty ()) { confirmation_height_bounded_processor.prepare_new (); @@ -102,14 +101,14 @@ void nano::confirmation_height_processor::run (confirmation_height_mode mode_a) // If there are blocks pending cementing, then make sure we flush out the remaining writes if (!confirmation_height_bounded_processor.pending_empty ()) { - assert (confirmation_height_unbounded_processor.pending_empty ()); + debug_assert (confirmation_height_unbounded_processor.pending_empty ()); auto scoped_write_guard = write_database_queue.wait (nano::writer::confirmation_height); confirmation_height_bounded_processor.cement_blocks (); lock_and_cleanup (); } else if (!confirmation_height_unbounded_processor.pending_empty ()) { - assert (confirmation_height_bounded_processor.pending_empty ()); + debug_assert (confirmation_height_bounded_processor.pending_empty ()); auto scoped_write_guard = write_database_queue.wait (nano::writer::confirmation_height); confirmation_height_unbounded_processor.cement_blocks (); lock_and_cleanup (); @@ -147,7 +146,7 @@ void nano::confirmation_height_processor::add (nano::block_hash const & hash_a) void nano::confirmation_height_processor::set_next_hash () { nano::lock_guard guard (mutex); - assert (!awaiting_processing.empty ()); + debug_assert (!awaiting_processing.empty ()); original_hash = *awaiting_processing.begin (); original_hashes_pending.insert (original_hash); awaiting_processing.erase (original_hash); diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index a93a207c68..a5327da9d5 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -172,7 +172,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source if (!hit_receive && !block_callback_data_a.empty ()) { // Add the callbacks to the associated receive to retrieve later - assert (!receive_source_pairs_a.empty ()); + debug_assert (!receive_source_pairs_a.empty ()); auto & last_receive_details = receive_source_pairs_a.back ().receive_details; last_receive_details->source_block_callback_data.assign (block_callback_data_a.begin (), block_callback_data_a.end ()); block_callback_data_a.clear (); @@ -243,13 +243,13 @@ void nano::confirmation_height_unbounded::prepare_iterated_blocks_for_cementing } else { - assert (receive_details); + debug_assert (receive_details); if (preparation_data_a.already_traversed && receive_details->source_block_callback_data.empty ()) { // We are confirming a block which has already been traversed and found no associated receive details for it. auto & above_receive_details_w = implicit_receive_cemented_mapping[preparation_data_a.current]; - assert (!above_receive_details_w.expired ()); + debug_assert (!above_receive_details_w.expired ()); auto above_receive_details = above_receive_details_w.lock (); auto num_blocks_already_confirmed = above_receive_details->num_blocks_confirmed - (above_receive_details->height - preparation_data_a.confirmation_height); @@ -289,7 +289,7 @@ void nano::confirmation_height_unbounded::prepare_iterated_blocks_for_cementing // Get the difference and remove the callbacks auto block_callbacks_to_remove = orig_num_blocks_confirmed - receive_details->num_blocks_confirmed; receive_details->block_callback_data.erase (std::next (receive_details->block_callback_data.rbegin (), block_callbacks_to_remove).base (), receive_details->block_callback_data.end ()); - assert (receive_details->block_callback_data.size () == receive_details->num_blocks_confirmed); + debug_assert (receive_details->block_callback_data.size () == receive_details->num_blocks_confirmed); } else { @@ -324,8 +324,8 @@ bool nano::confirmation_height_unbounded::cement_blocks () nano::block_sideband sideband; auto block = ledger.store.block_get (transaction, pending.hash, &sideband); static nano::network_constants network_constants; - assert (network_constants.is_test_network () || block != nullptr); - assert (network_constants.is_test_network () || sideband.height == pending.height); + debug_assert (network_constants.is_test_network () || block != nullptr); + debug_assert (network_constants.is_test_network () || sideband.height == pending.height); if (!block) { @@ -337,7 +337,7 @@ bool nano::confirmation_height_unbounded::cement_blocks () #endif ledger.stats.add (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in, pending.height - confirmation_height); ledger.stats.add (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed_unbounded, nano::stat::dir::in, pending.height - confirmation_height); - assert (pending.num_blocks_confirmed == pending.height - confirmation_height); + debug_assert (pending.num_blocks_confirmed == pending.height - confirmation_height); confirmation_height = pending.height; ledger.cache.cemented_count += pending.num_blocks_confirmed; ledger.store.confirmation_height_put (transaction, pending.account, { confirmation_height, pending.hash }); @@ -349,7 +349,7 @@ bool nano::confirmation_height_unbounded::cement_blocks () std::vector callback_data; callback_data.reserve (pending.block_callback_data.size ()); std::transform (pending.block_callback_data.begin (), pending.block_callback_data.end (), std::back_inserter (callback_data), [& block_cache = block_cache](auto const & hash_a) { - assert (block_cache.find (hash_a) != block_cache.end ()); + debug_assert (block_cache.find (hash_a) != block_cache.end ()); return block_cache.at (hash_a); }); @@ -359,8 +359,8 @@ bool nano::confirmation_height_unbounded::cement_blocks () total_pending_write_block_count -= pending.num_blocks_confirmed; pending_writes.erase (pending_writes.begin ()); } - assert (total_pending_write_block_count == 0); - assert (pending_writes.empty ()); + debug_assert (total_pending_write_block_count == 0); + debug_assert (pending_writes.empty ()); return false; } diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp index 34caaf2c9d..f86019b0ae 100644 --- a/nano/node/confirmation_solicitor.cpp +++ b/nano/node/confirmation_solicitor.cpp @@ -13,7 +13,7 @@ network (network_a) void nano::confirmation_solicitor::prepare (std::vector const & representatives_a) { - assert (!prepared); + debug_assert (!prepared); requests.clear (); rebroadcasted = 0; representatives = representatives_a; @@ -22,7 +22,7 @@ void nano::confirmation_solicitor::prepare (std::vector co bool nano::confirmation_solicitor::broadcast (nano::election const & election_a) { - assert (prepared); + debug_assert (prepared); bool result (true); if (rebroadcasted++ < max_block_broadcasts) { @@ -34,7 +34,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a) bool nano::confirmation_solicitor::add (nano::election const & election_a) { - assert (prepared); + debug_assert (prepared); auto const max_channel_requests (max_confirm_req_batches * nano::network::confirm_req_hashes_max); unsigned count = 0; for (auto i (representatives.begin ()), n (representatives.end ()); i != n && count < max_election_requests; ++i) @@ -55,7 +55,7 @@ bool nano::confirmation_solicitor::add (nano::election const & election_a) void nano::confirmation_solicitor::flush () { - assert (prepared); + debug_assert (prepared); for (auto const & request_queue : requests) { auto const & channel (request_queue.first); diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index e4e1ff5be8..0e09d11601 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -29,13 +29,13 @@ strand (node_a.io_ctx.get_executor ()), need_resolve (request_a.peers), elapsed (nano::timer_state::started, "distributed work generation timer") { - assert (!finished); - assert (status == work_generation_status::ongoing); + debug_assert (!finished); + debug_assert (status == work_generation_status::ongoing); } nano::distributed_work::~distributed_work () { - assert (status != work_generation_status::ongoing); + debug_assert (status != work_generation_status::ongoing); if (auto node_l = node_w.lock ()) { if (!node_l->stopped && node_l->websocket_server && node_l->websocket_server->any_subscriber (nano::websocket::topic::work)) diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 4f6131a5f2..5e7b9c335f 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -25,7 +25,7 @@ stopped (false) void nano::election::confirm_once (nano::election_status_type type_a) { - assert (!node.active.mutex.try_lock ()); + debug_assert (!node.active.mutex.try_lock ()); if (!confirmed_m.exchange (true)) { status.election_end = std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()); @@ -50,7 +50,7 @@ void nano::election::confirm_once (nano::election_status_type type_a) void nano::election::stop () { - assert (!node.active.mutex.try_lock ()); + debug_assert (!node.active.mutex.try_lock ()); if (!stopped && !confirmed ()) { stopped = true; @@ -105,22 +105,25 @@ nano::tally_t nano::election::tally () void nano::election::confirm_if_quorum () { auto tally_l (tally ()); - assert (!tally_l.empty ()); + debug_assert (!tally_l.empty ()); auto winner (tally_l.begin ()); auto block_l (winner->second); + auto winner_hash_l (block_l->hash ()); status.tally = winner->first; + auto status_winner_hash_l (status.winner->hash ()); nano::uint128_t sum (0); for (auto & i : tally_l) { sum += i.first; } - if (sum >= node.config.online_weight_minimum.number () && block_l->hash () != status.winner->hash ()) + if (sum >= node.config.online_weight_minimum.number () && winner_hash_l != status_winner_hash_l) { - auto node_l (node.shared ()); - node_l->block_processor.force (block_l); + node.votes_cache.remove (status_winner_hash_l); + node.block_processor.generator.add (winner_hash_l); + node.block_processor.force (block_l); status.winner = block_l; update_dependent (); - node_l->active.adjust_difficulty (block_l->hash ()); + node.active.adjust_difficulty (winner_hash_l); } if (have_quorum (tally_l, sum)) { @@ -243,7 +246,7 @@ size_t nano::election::last_votes_size () void nano::election::update_dependent () { - assert (!node.active.mutex.try_lock ()); + debug_assert (!node.active.mutex.try_lock ()); std::vector blocks_search; auto hash (status.winner->hash ()); auto previous (status.winner->previous ()); @@ -291,7 +294,7 @@ void nano::election::clear_blocks () auto erased (node.active.blocks.erase (hash)); (void)erased; // clear_blocks () can be called in active_transactions::publish () before blocks insertion if election was confirmed - assert (erased == 1 || confirmed ()); + debug_assert (erased == 1 || confirmed ()); node.active.erase_inactive_votes_cache (hash); // Notify observers about dropped elections & blocks lost confirmed elections if (stopped || hash != winner_hash) diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 4ab2358c2f..20813943d3 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -114,7 +114,7 @@ nanoapi::BlockUnion nano::ipc::flatbuffers_builder::block_to_union (nano::block } default: - assert (false); + debug_assert (false); } return u; } diff --git a/nano/node/ipc/ipc_broker.cpp b/nano/node/ipc/ipc_broker.cpp index 46ccdf0b80..65922c7419 100644 --- a/nano/node/ipc/ipc_broker.cpp +++ b/nano/node/ipc/ipc_broker.cpp @@ -22,7 +22,7 @@ std::shared_ptr nano::ipc::subscriber::get_parser (nano::ip void nano::ipc::broker::start () { node.observers.blocks.add ([this](nano::election_status const & status_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { - assert (status_a.type != nano::election_status_type::ongoing); + debug_assert (status_a.type != nano::election_status_type::ongoing); try { @@ -46,7 +46,7 @@ void nano::ipc::broker::start () confirmation->confirmation_type = nanoapi::TopicConfirmationType::TopicConfirmationType_inactive; break; default: - assert (false); + debug_assert (false); break; }; confirmation->confirmation_type = nanoapi::TopicConfirmationType::TopicConfirmationType_active_quorum; @@ -119,7 +119,7 @@ void nano::ipc::broker::broadcast (std::shared_ptr if (auto subscriber_l = itr->subscriber.lock ()) { auto should_filter = [this, &itr, confirmation_a]() { - assert (itr->topic->options != nullptr); + debug_assert (itr->topic->options != nullptr); auto conf_filter (itr->topic->options->confirmation_type_filter); bool should_filter_conf_type_l (true); @@ -148,7 +148,7 @@ void nano::ipc::broker::broadcast (std::shared_ptr auto decode_destination_ok_l (!destination_l.decode_account (state->link_as_account)); (void)decode_source_ok_l; (void)decode_destination_ok_l; - assert (decode_source_ok_l && decode_destination_ok_l); + debug_assert (decode_source_ok_l && decode_destination_ok_l); if (this->node.wallets.exists (transaction_l, source_l) || this->node.wallets.exists (transaction_l, destination_l)) { should_filter_account_l = false; diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 400aed30d7..f4c1d61e42 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -2059,7 +2059,7 @@ void epoch_upgrader (std::shared_ptr node_a, nano::private_key const nano::raw_key raw_key; raw_key.data = prv_a; auto signer (nano::pub_key (prv_a)); - assert (signer == node_a->ledger.epoch_signer (link)); + debug_assert (signer == node_a->ledger.epoch_signer (link)); class account_upgrade_item final { @@ -3941,7 +3941,6 @@ void nano::json_handler::telemetry () nano::jsonconfig config_l; auto err = telemetry_data.serialize_json (config_l); - config_l.put ("timestamp", std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()).count ()); auto const & ptree = config_l.get_tree (); if (!err) @@ -3978,13 +3977,12 @@ void nano::json_handler::telemetry () if (!ec) { - assert (channel); - node.telemetry.get_metrics_single_peer_async (channel, [rpc_l](auto const & single_telemetry_metric_a) { - if (!single_telemetry_metric_a.error) + debug_assert (channel); + node.telemetry.get_metrics_single_peer_async (channel, [rpc_l](auto const & telemetry_response_a) { + if (!telemetry_response_a.error) { nano::jsonconfig config_l; - auto err = single_telemetry_metric_a.telemetry_data_time_pair.data.serialize_json (config_l); - config_l.put ("timestamp", std::chrono::duration_cast (single_telemetry_metric_a.telemetry_data_time_pair.system_last_updated.time_since_epoch ()).count ()); + auto err = telemetry_response_a.telemetry_data.serialize_json (config_l); auto const & ptree = config_l.get_tree (); if (!err) @@ -4015,15 +4013,14 @@ void nano::json_handler::telemetry () // setting "raw" to true returns metrics from all nodes requested. auto raw = request.get_optional ("raw"); auto output_raw = raw.value_or (false); - node.telemetry.get_metrics_peers_async ([rpc_l, output_raw](auto const & batched_telemetry_metrics_a) { + node.telemetry.get_metrics_peers_async ([rpc_l, output_raw](telemetry_data_responses const & telemetry_responses_a) { if (output_raw) { boost::property_tree::ptree metrics; - for (auto & telemetry_metrics : batched_telemetry_metrics_a.telemetry_data_time_pairs) + for (auto & telemetry_metrics : telemetry_responses_a.telemetry_datas) { nano::jsonconfig config_l; - auto err = telemetry_metrics.second.data.serialize_json (config_l); - config_l.put ("timestamp", std::chrono::duration_cast (telemetry_metrics.second.system_last_updated.time_since_epoch ()).count ()); + auto err = telemetry_metrics.second.serialize_json (config_l); config_l.put ("address", telemetry_metrics.first.address ()); config_l.put ("port", telemetry_metrics.first.port ()); if (!err) @@ -4041,15 +4038,14 @@ void nano::json_handler::telemetry () else { nano::jsonconfig config_l; - std::vector telemetry_data_time_pairs; - telemetry_data_time_pairs.reserve (batched_telemetry_metrics_a.telemetry_data_time_pairs.size ()); - std::transform (batched_telemetry_metrics_a.telemetry_data_time_pairs.begin (), batched_telemetry_metrics_a.telemetry_data_time_pairs.end (), std::back_inserter (telemetry_data_time_pairs), [](auto const & telemetry_data_time_pair_a) { - return telemetry_data_time_pair_a.second; + std::vector telemetry_datas; + telemetry_datas.reserve (telemetry_responses_a.telemetry_datas.size ()); + std::transform (telemetry_responses_a.telemetry_datas.begin (), telemetry_responses_a.telemetry_datas.end (), std::back_inserter (telemetry_datas), [](auto const & endpoint_telemetry_data) { + return endpoint_telemetry_data.second; }); - auto average_telemetry_metrics = nano::consolidate_telemetry_data_time_pairs (telemetry_data_time_pairs); - auto err = average_telemetry_metrics.data.serialize_json (config_l); - config_l.put ("timestamp", std::chrono::duration_cast (average_telemetry_metrics.system_last_updated.time_since_epoch ()).count ()); + auto average_telemetry_metrics = nano::consolidate_telemetry_data (telemetry_datas); + auto err = average_telemetry_metrics.serialize_json (config_l); auto const & ptree = config_l.get_tree (); if (!err) @@ -4100,7 +4096,7 @@ void nano::json_handler::unchecked_clear () { auto rpc_l (shared_from_this ()); node.worker.push_task ([rpc_l]() { - auto transaction (rpc_l->node.store.tx_begin_write ()); + auto transaction (rpc_l->node.store.tx_begin_write ({ tables::unchecked })); rpc_l->node.store.unchecked_clear (transaction); rpc_l->node.ledger.cache.unchecked_count = 0; rpc_l->response_l.put ("success", ""); @@ -4428,7 +4424,7 @@ void nano::json_handler::wallet_change_seed () rpc_l->response_l.put ("success", ""); rpc_l->response_l.put ("last_restored_account", account.to_account ()); auto index (wallet->store.deterministic_index_get (transaction)); - assert (index > 0); + debug_assert (index > 0); rpc_l->response_l.put ("restored_count", std::to_string (index)); } else @@ -4487,7 +4483,7 @@ void nano::json_handler::wallet_create () nano::public_key account (wallet->change_seed (transaction, seed)); rpc_l->response_l.put ("last_restored_account", account.to_account ()); auto index (wallet->store.deterministic_index_get (transaction)); - assert (index > 0); + debug_assert (index > 0); rpc_l->response_l.put ("restored_count", std::to_string (index)); } } diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp index 2eb700b249..f013e06fb7 100644 --- a/nano/node/lmdb/lmdb.cpp +++ b/nano/node/lmdb/lmdb.cpp @@ -310,7 +310,7 @@ void nano::mdb_store::upgrade_v2_to_v3 (nano::write_transaction const & transact nano::account_info_v5 info ((*i)->second); representative_visitor visitor (transaction_a, *this); visitor.compute (info.head); - assert (!visitor.result.is_zero ()); + debug_assert (!visitor.result.is_zero ()); info.rep_block = visitor.result; auto impl (boost::polymorphic_downcast *> (i.get ())); mdb_cursor_put (impl->cursor, nano::mdb_val (account_l), nano::mdb_val (sizeof (info), &info), MDB_CURRENT); @@ -331,7 +331,7 @@ void nano::mdb_store::upgrade_v3_to_v4 (nano::write_transaction const & transact while (!items.empty ()) { auto status (mdb_put (env.tx (transaction_a), pending, nano::mdb_val (items.front ().first), nano::mdb_val (items.front ().second), 0)); - assert (success (status)); + debug_assert (success (status)); items.pop (); } } @@ -360,7 +360,7 @@ void nano::mdb_store::upgrade_v4_to_v5 (nano::write_transaction const & transact { nano::block_type type; auto value (block_raw_get (transaction_a, block->previous (), type)); - assert (value.size () != 0); + debug_assert (value.size () != 0); std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); std::copy (hash.bytes.begin (), hash.bytes.end (), data.end () - nano::block_sideband::size (type)); block_raw_put (transaction_a, data, type, block->previous ()); @@ -386,7 +386,7 @@ void nano::mdb_store::upgrade_v5_to_v6 (nano::write_transaction const & transact { ++block_count; auto block (block_get (transaction_a, hash)); - assert (block != nullptr); + debug_assert (block != nullptr); hash = block->previous (); } headers.emplace_back (account, nano::account_info_v13{ info_old.head, info_old.rep_block, info_old.open_block, info_old.balance, info_old.modified, block_count, nano::epoch::epoch_0 }); @@ -434,7 +434,7 @@ void nano::mdb_store::upgrade_v8_to_v9 (nano::write_transaction const & transact } auto status1 (mdb_put (env.tx (transaction_a), vote, nano::mdb_val (i->first), nano::mdb_val (vector.size (), vector.data ()), 0)); release_assert (status1 == 0); - assert (!error); + debug_assert (!error); } mdb_drop (env.tx (transaction_a), sequence, 1); } @@ -494,7 +494,7 @@ void nano::mdb_store::upgrade_v12_to_v13 (nano::write_transaction & transaction_ bool is_state_block_v1 = false; auto block = block_get_v14 (transaction_a, hash, &sideband, &is_state_block_v1); - assert (block != nullptr); + debug_assert (block != nullptr); if (sideband.height == 0) { sideband.height = height; @@ -514,7 +514,7 @@ void nano::mdb_store::upgrade_v12_to_v13 (nano::write_transaction & transaction_ nano::block_predecessor_set predecessor (transaction_a, *this); block->visit (predecessor); - assert (block->previous ().is_zero () || block_successor (transaction_a, block->previous ()) == hash); + debug_assert (block->previous ().is_zero () || block_successor (transaction_a, block->previous ()) == hash); cost += 16; } else @@ -598,7 +598,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ logger.always_log ("Finished extracting confirmation height to its own database"); - assert (account_counters.are_equal ()); + debug_assert (account_counters.are_equal ()); // No longer need accounts_v1, keep v0 but clear it mdb_drop (env.tx (transaction_a), accounts_v1, 1); mdb_drop (env.tx (transaction_a), accounts_v0, 0); @@ -651,7 +651,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ i_state.from_first_database ? ++state_counters.after_v0 : ++state_counters.after_v1; } - assert (state_counters.are_equal ()); + debug_assert (state_counters.are_equal ()); logger.always_log ("Epoch merge upgrade: Finished state blocks, now doing pending blocks"); state_blocks = state_blocks_new; @@ -675,7 +675,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ i_pending.from_first_database ? ++pending_counters.after_v0 : ++pending_counters.after_v1; } - assert (pending_counters.are_equal ()); + debug_assert (pending_counters.are_equal ()); // No longer need the pending v1 table mdb_drop (env.tx (transaction_a), pending_v1, 1); @@ -693,7 +693,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ void nano::mdb_store::upgrade_v15_to_v16 (nano::write_transaction const & transaction_a) { // Representation table is no longer used - assert (representation != 0); + debug_assert (representation != 0); if (representation != 0) { auto status (mdb_drop (env.tx (transaction_a), representation, 1)); @@ -719,7 +719,7 @@ void nano::mdb_store::upgrade_v16_to_v17 (nano::write_transaction const & transa uint64_t confirmation_height (i->second); // Check account hashes matches both the accounts table and confirmation height table - assert (account == account_info_i->first); + debug_assert (account == account_info_i->first); auto const & account_info = account_info_i->second; @@ -734,17 +734,17 @@ void nano::mdb_store::upgrade_v16_to_v17 (nano::write_transaction const & transa // The confirmation height of the account is closer to the bottom of the chain, so start there and work up nano::block_sideband sideband; auto block = block_get (transaction_a, account_info.open_block, &sideband); - assert (block); + debug_assert (block); auto height = 1; while (height != confirmation_height) { block = block_get (transaction_a, sideband.successor, &sideband); - assert (block); + debug_assert (block); ++height; } - assert (sideband.height == confirmation_height); + debug_assert (sideband.height == confirmation_height); confirmation_height_infos.emplace_back (account, confirmation_height_info{ confirmation_height, block->hash () }); } else @@ -756,7 +756,7 @@ void nano::mdb_store::upgrade_v16_to_v17 (nano::write_transaction const & transa while (height != confirmation_height) { block = block_get (transaction_a, block->previous ()); - assert (block); + debug_assert (block); --height; } confirmation_height_infos.emplace_back (account, confirmation_height_info{ confirmation_height, block->hash () }); @@ -899,7 +899,7 @@ void nano::mdb_store::version_put (nano::write_transaction const & transaction_a bool nano::mdb_store::block_info_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_info & block_info_a) const { - assert (!full_sideband (transaction_a)); + debug_assert (!full_sideband (transaction_a)); nano::mdb_val value; auto status (mdb_get (env.tx (transaction_a), blocks_info, nano::mdb_val (hash_a), value)); release_assert (status == 0 || status == MDB_NOTFOUND); @@ -907,14 +907,14 @@ bool nano::mdb_store::block_info_get (nano::transaction const & transaction_a, n if (status != MDB_NOTFOUND) { result = false; - assert (value.size () == sizeof (block_info_a.account.bytes) + sizeof (block_info_a.balance.bytes)); + debug_assert (value.size () == sizeof (block_info_a.account.bytes) + sizeof (block_info_a.balance.bytes)); nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); auto error1 (nano::try_read (stream, block_info_a.account)); (void)error1; - assert (!error1); + debug_assert (!error1); auto error2 (nano::try_read (stream, block_info_a.balance)); (void)error2; - assert (!error2); + debug_assert (!error2); } return result; } @@ -1096,7 +1096,7 @@ size_t nano::mdb_store::block_successor_offset_v14 (nano::transaction const & tr else { // Read old successor-only sideband - assert (entry_size_a == nano::block::size (type_a) + sizeof (nano::uint256_union)); + debug_assert (entry_size_a == nano::block::size (type_a) + sizeof (nano::uint256_union)); result = entry_size_a - sizeof (nano::uint256_union); } return result; @@ -1109,11 +1109,11 @@ nano::block_hash nano::mdb_store::block_successor_v14 (nano::transaction const & nano::block_hash result; if (value.size () != 0) { - assert (value.size () >= result.bytes.size ()); + debug_assert (value.size () >= result.bytes.size ()); nano::bufferstream stream (reinterpret_cast (value.data ()) + block_successor_offset_v14 (transaction_a, value.size (), type), result.bytes.size ()); auto error (nano::try_read (stream, result.bytes)); (void)error; - assert (!error); + debug_assert (!error); } else { @@ -1206,20 +1206,20 @@ nano::account nano::mdb_store::block_account_v14 (nano::transaction const & tran { result = sideband.account; } - assert (!result.is_zero ()); + debug_assert (!result.is_zero ()); return result; } // Return account containing hash nano::account nano::mdb_store::block_account_computed_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - assert (!full_sideband (transaction_a)); + debug_assert (!full_sideband (transaction_a)); nano::account result (0); auto hash (hash_a); while (result.is_zero ()) { auto block (block_get_v14 (transaction_a, hash)); - assert (block); + debug_assert (block); result = block->account (); if (result.is_zero ()) { @@ -1242,20 +1242,20 @@ nano::account nano::mdb_store::block_account_computed_v14 (nano::transaction con if (result.is_zero ()) { auto successor (block_successor_v14 (transaction_a, hash)); - assert (!successor.is_zero ()); + debug_assert (!successor.is_zero ()); hash = successor; } } } } } - assert (!result.is_zero ()); + debug_assert (!result.is_zero ()); return result; } nano::uint128_t nano::mdb_store::block_balance_computed_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - assert (!full_sideband (transaction_a)); + debug_assert (!full_sideband (transaction_a)); summation_visitor visitor (transaction_a, *this, true); return visitor.compute_balance (hash_a); } @@ -1269,7 +1269,7 @@ std::shared_ptr nano::mdb_store::block_get_v14 (nano::transaction c { nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); result = nano::deserialize_block (stream, type); - assert (result != nullptr); + debug_assert (result != nullptr); if (sideband_a) { sideband_a->type = type; @@ -1277,7 +1277,7 @@ std::shared_ptr nano::mdb_store::block_get_v14 (nano::transaction c { bool error = sideband_a->deserialize (stream); (void)error; - assert (!error); + debug_assert (!error); } else { diff --git a/nano/node/lmdb/lmdb_iterator.hpp b/nano/node/lmdb/lmdb_iterator.hpp index 6f1e7e1305..d225cb4136 100644 --- a/nano/node/lmdb/lmdb_iterator.hpp +++ b/nano/node/lmdb/lmdb_iterator.hpp @@ -74,7 +74,7 @@ class mdb_iterator : public store_iterator_impl nano::store_iterator_impl & operator++ () override { - assert (cursor != nullptr); + debug_assert (cursor != nullptr); auto status (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_NEXT)); release_assert (status == 0 || status == MDB_NOTFOUND); if (status == MDB_NOTFOUND) @@ -97,9 +97,9 @@ class mdb_iterator : public store_iterator_impl { auto const other_a (boost::polymorphic_downcast const *> (&base_a)); auto result (current.first.data () == other_a->current.first.data ()); - assert (!result || (current.first.size () == other_a->current.first.size ())); - assert (!result || (current.second.data () == other_a->current.second.data ())); - assert (!result || (current.second.size () == other_a->current.second.size ())); + debug_assert (!result || (current.first.size () == other_a->current.first.size ())); + debug_assert (!result || (current.second.data () == other_a->current.second.data ())); + debug_assert (!result || (current.second.size () == other_a->current.second.size ())); return result; } @@ -130,7 +130,7 @@ class mdb_iterator : public store_iterator_impl { current.first = nano::db_val (); current.second = nano::db_val (); - assert (is_end_sentinal ()); + debug_assert (is_end_sentinal ()); } nano::mdb_iterator & operator= (nano::mdb_iterator && other_a) @@ -203,7 +203,7 @@ class mdb_merge_iterator : public store_iterator_impl bool operator== (nano::store_iterator_impl const & base_a) const override { - assert ((dynamic_cast const *> (&base_a) != nullptr) && "Incompatible iterator comparison"); + debug_assert ((dynamic_cast const *> (&base_a) != nullptr) && "Incompatible iterator comparison"); auto & other (static_cast const &> (base_a)); return *impl1 == *other.impl1 && *impl2 == *other.impl2; } diff --git a/nano/node/lmdb/lmdb_txn.cpp b/nano/node/lmdb/lmdb_txn.cpp index 1af015fadd..405fd84e26 100644 --- a/nano/node/lmdb/lmdb_txn.cpp +++ b/nano/node/lmdb/lmdb_txn.cpp @@ -147,7 +147,7 @@ void nano::mdb_txn_tracker::serialize_json (boost::property_tree::ptree & json, std::transform (copy_stats.cbegin (), copy_stats.cend (), std::back_inserter (times_since_start), [](const auto & stat) { return stat.timer.since_start (); }); - assert (times_since_start.size () == copy_stats.size ()); + debug_assert (times_since_start.size () == copy_stats.size ()); for (size_t i = 0; i < times_since_start.size (); ++i) { @@ -197,7 +197,7 @@ void nano::mdb_txn_tracker::output_finished (nano::mdb_txn_stats const & mdb_txn if (!should_ignore && ((is_write && time_open >= txn_tracking_config.min_write_txn_time) || (!is_write && time_open >= txn_tracking_config.min_read_txn_time))) { - assert (mdb_txn_stats.stacktrace); + debug_assert (mdb_txn_stats.stacktrace); logger.always_log (boost::str (boost::format ("%1%ms %2% held on thread %3%\n%4%") % mdb_txn_stats.timer.since_start ().count () % (is_write ? "write lock" : "read") % mdb_txn_stats.thread_name % *mdb_txn_stats.stacktrace)); } } @@ -205,7 +205,7 @@ void nano::mdb_txn_tracker::output_finished (nano::mdb_txn_stats const & mdb_txn void nano::mdb_txn_tracker::add (const nano::transaction_impl * transaction_impl) { nano::lock_guard guard (mutex); - assert (std::find_if (stats.cbegin (), stats.cend (), matches_txn (transaction_impl)) == stats.cend ()); + debug_assert (std::find_if (stats.cbegin (), stats.cend (), matches_txn (transaction_impl)) == stats.cend ()); stats.emplace_back (transaction_impl); } diff --git a/nano/node/lmdb/wallet_value.cpp b/nano/node/lmdb/wallet_value.cpp index 91c8a6797a..1e5aa315ea 100644 --- a/nano/node/lmdb/wallet_value.cpp +++ b/nano/node/lmdb/wallet_value.cpp @@ -2,7 +2,7 @@ nano::wallet_value::wallet_value (nano::db_val const & val_a) { - assert (val_a.size () == sizeof (*this)); + debug_assert (val_a.size () == sizeof (*this)); std::copy (reinterpret_cast (val_a.data ()), reinterpret_cast (val_a.data ()) + sizeof (key), key.chars.begin ()); std::copy (reinterpret_cast (val_a.data ()) + sizeof (key), reinterpret_cast (val_a.data ()) + sizeof (key) + sizeof (work), reinterpret_cast (&work)); } diff --git a/nano/node/logging.cpp b/nano/node/logging.cpp index 17f756f4c9..66bf4e1d23 100644 --- a/nano/node/logging.cpp +++ b/nano/node/logging.cpp @@ -68,9 +68,48 @@ void nano::logging::init (boost::filesystem::path const & application_path_a) #endif } +//clang-format off +#if BOOST_VERSION < 107000 + if (stable_log_filename) + { + stable_log_filename = false; + std::cerr << "The stable_log_filename config setting is only available when building with Boost 1.70 or later. Reverting to old behavior." << std::endl; + } +#endif + auto path = application_path_a / "log"; - file_sink = boost::log::add_file_log (boost::log::keywords::target = path, boost::log::keywords::file_name = path / "log_%Y-%m-%d_%H-%M-%S.%N.log", boost::log::keywords::rotation_size = rotation_size, boost::log::keywords::auto_flush = flush, boost::log::keywords::scan_method = boost::log::sinks::file::scan_method::scan_matching, boost::log::keywords::max_size = max_size, boost::log::keywords::format = format_with_timestamp); + if (stable_log_filename) + { +#if BOOST_VERSION >= 107000 + // Logging to node.log and node_ instead of log_.log is deliberate. This way, + // existing log monitoring scripts expecting the old logfile structure will fail immediately instead + // of reading only rotated files with old entries. + file_sink = boost::log::add_file_log (boost::log::keywords::target = path, + boost::log::keywords::file_name = path / "node.log", + boost::log::keywords::target_file_name = path / "node_%Y-%m-%d_%H-%M-%S.%N.log", + boost::log::keywords::open_mode = std::ios_base::out | std::ios_base::app, // append to node.log if it exists + boost::log::keywords::enable_final_rotation = false, // for stable log filenames, don't rotate on destruction + boost::log::keywords::rotation_size = rotation_size, // max file size in bytes before rotation + boost::log::keywords::auto_flush = flush, + boost::log::keywords::scan_method = boost::log::sinks::file::scan_method::scan_matching, + boost::log::keywords::max_size = max_size, // max total size in bytes of all log files + boost::log::keywords::format = format_with_timestamp); +#else + debug_assert (false); +#endif + } + else + { + file_sink = boost::log::add_file_log (boost::log::keywords::target = path, + boost::log::keywords::file_name = path / "log_%Y-%m-%d_%H-%M-%S.%N.log", + boost::log::keywords::rotation_size = rotation_size, + boost::log::keywords::auto_flush = flush, + boost::log::keywords::scan_method = boost::log::sinks::file::scan_method::scan_matching, + boost::log::keywords::max_size = max_size, + boost::log::keywords::format = format_with_timestamp); + } } + //clang-format on } void nano::logging::release_file_sink () @@ -109,6 +148,7 @@ nano::error nano::logging::serialize_toml (nano::tomlconfig & toml) const toml.put ("flush", flush, "If enabled, immediately flush new entries to log file.\nWarning: this may negatively affect logging performance.\ntype:bool"); toml.put ("min_time_between_output", min_time_between_log_output.count (), "Minimum time that must pass for low priority entries to be logged.\nWarning: decreasing this value may result in a very large amount of logs.\ntype:milliseconds"); toml.put ("single_line_record", single_line_record_value, "Keep log entries on single lines.\ntype:bool"); + toml.put ("stable_log_filename", stable_log_filename, "Append to log/node.log without a timestamp in the filename.\nThe file is not emptied on startup if it exists, but appended to.\ntype:bool"); return toml.get_error (); } @@ -142,6 +182,7 @@ nano::error nano::logging::deserialize_toml (nano::tomlconfig & toml) auto min_time_between_log_output_l = min_time_between_log_output.count (); toml.get ("min_time_between_output", min_time_between_log_output_l); min_time_between_log_output = std::chrono::milliseconds (min_time_between_log_output_l); + toml.get ("stable_log_filename", stable_log_filename); return toml.get_error (); } diff --git a/nano/node/logging.hpp b/nano/node/logging.hpp index 61dcec5e0f..e42a7aba53 100644 --- a/nano/node/logging.hpp +++ b/nano/node/logging.hpp @@ -89,6 +89,7 @@ class logging final bool flush{ true }; uintmax_t max_size{ 128 * 1024 * 1024 }; uintmax_t rotation_size{ 4 * 1024 * 1024 }; + bool stable_log_filename{ false }; std::chrono::milliseconds min_time_between_log_output{ 5 }; bool single_line_record_value{ false }; static void release_file_sink (); diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 76ce9e38dd..3483bd474a 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -70,7 +70,7 @@ void nano::network::start () if (!node.flags.disable_udp) { udp_channels.start (); - assert (udp_channels.get_local_endpoint ().port () == port); + debug_assert (udp_channels.get_local_endpoint ().port () == port); } if (!node.flags.disable_tcp_realtime) { @@ -136,7 +136,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrfirst, *respond_to, response->second)); + debug_assert (!nano::validate_message (response->first, *respond_to, response->second)); } nano::node_id_handshake message (query, response); if (node.config.logging.network_node_id_handshake_logging ()) @@ -427,19 +427,19 @@ class network_message_visitor : public nano::message_visitor } void bulk_pull (nano::bulk_pull const &) override { - assert (false); + debug_assert (false); } void bulk_pull_account (nano::bulk_pull_account const &) override { - assert (false); + debug_assert (false); } void bulk_push (nano::bulk_push const &) override { - assert (false); + debug_assert (false); } void frontier_req (nano::frontier_req const &) override { - assert (false); + debug_assert (false); } void node_id_handshake (nano::node_id_handshake const & message_a) override { @@ -590,15 +590,15 @@ std::unordered_set> nano::network::ran void nano::network::random_fill (std::array & target_a) const { auto peers (random_set (target_a.size (), 0, false)); // Don't include channels with ephemeral remote ports - assert (peers.size () <= target_a.size ()); + debug_assert (peers.size () <= target_a.size ()); auto endpoint (nano::endpoint (boost::asio::ip::address_v6{}, 0)); - assert (endpoint.address ().is_v6 ()); + debug_assert (endpoint.address ().is_v6 ()); std::fill (target_a.begin (), target_a.end (), endpoint); auto j (target_a.begin ()); for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i, ++j) { - assert ((*i)->get_endpoint ().address ().is_v6 ()); - assert (j < target_a.end ()); + debug_assert ((*i)->get_endpoint ().address ().is_v6 ()); + debug_assert (j < target_a.end ()); *j = (*i)->get_endpoint (); } } @@ -713,8 +713,8 @@ slab (size * count), entries (count), stopped (false) { - assert (count > 0); - assert (size > 0); + debug_assert (count > 0); + debug_assert (size > 0); auto slab_data (slab.data ()); auto entry_data (entries.data ()); for (auto i (0); i < count; ++i, ++entry_data) @@ -750,7 +750,7 @@ nano::message_buffer * nano::message_buffer_manager::allocate () void nano::message_buffer_manager::enqueue (nano::message_buffer * data_a) { - assert (data_a != nullptr); + debug_assert (data_a != nullptr); { nano::lock_guard lock (mutex); full.push_back (data_a); @@ -776,7 +776,7 @@ nano::message_buffer * nano::message_buffer_manager::dequeue () void nano::message_buffer_manager::release (nano::message_buffer * data_a) { - assert (data_a != nullptr); + debug_assert (data_a != nullptr); { nano::lock_guard lock (mutex); free.push_back (data_a); @@ -796,7 +796,7 @@ void nano::message_buffer_manager::stop () boost::optional nano::syn_cookies::assign (nano::endpoint const & endpoint_a) { auto ip_addr (endpoint_a.address ()); - assert (ip_addr.is_v6 ()); + debug_assert (ip_addr.is_v6 ()); nano::lock_guard lock (syn_cookie_mutex); unsigned & ip_cookies = cookies_per_ip[ip_addr]; boost::optional result; @@ -818,7 +818,7 @@ boost::optional nano::syn_cookies::assign (nano::endpoint c bool nano::syn_cookies::validate (nano::endpoint const & endpoint_a, nano::account const & node_id, nano::signature const & sig) { auto ip_addr (endpoint_a.address ()); - assert (ip_addr.is_v6 ()); + debug_assert (ip_addr.is_v6 ()); nano::lock_guard lock (syn_cookie_mutex); auto result (true); auto cookie_it (cookies.find (endpoint_a)); @@ -833,7 +833,7 @@ bool nano::syn_cookies::validate (nano::endpoint const & endpoint_a, nano::accou } else { - assert (false && "More SYN cookies deleted than created for IP"); + debug_assert (false && "More SYN cookies deleted than created for IP"); } } return result; @@ -855,7 +855,7 @@ void nano::syn_cookies::purge (std::chrono::steady_clock::time_point const & cut } else { - assert (false && "More SYN cookies deleted than created for IP"); + debug_assert (false && "More SYN cookies deleted than created for IP"); } it = cookies.erase (it); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 636413bb3b..aa2716a69c 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -164,7 +164,7 @@ startup_time (std::chrono::steady_clock::now ()) observers.wallet.notify (active); }; network.channel_observer = [this](std::shared_ptr channel_a) { - assert (channel_a != nullptr); + debug_assert (channel_a != nullptr); observers.endpoint.notify (channel_a); }; network.disconnect_observer = [this]() { @@ -235,7 +235,7 @@ startup_time (std::chrono::steady_clock::now ()) if (websocket_server) { observers.blocks.add ([this](nano::election_status const & status_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { - assert (status_a.type != nano::election_status_type::ongoing); + debug_assert (status_a.type != nano::election_status_type::ongoing); if (this->websocket_server->any_subscriber (nano::websocket::topic::confirmation)) { @@ -284,7 +284,7 @@ startup_time (std::chrono::steady_clock::now ()) } // Add block confirmation type stats regardless of http-callback and websocket subscriptions observers.blocks.add ([this](nano::election_status const & status_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { - assert (status_a.type != nano::election_status_type::ongoing); + debug_assert (status_a.type != nano::election_status_type::ongoing); switch (status_a.type) { case nano::election_status_type::active_confirmed_quorum: @@ -367,7 +367,7 @@ startup_time (std::chrono::steady_clock::now ()) if (!is_initialized) { release_assert (!flags.read_only); - auto transaction (store.tx_begin_write ()); + auto transaction (store.tx_begin_write ({ tables::accounts, tables::cached_counts, tables::confirmation_height, tables::frontiers, tables::open_blocks })); // Store was empty meaning we just created it, add the genesis block store.initialize (transaction, genesis, ledger.cache); } @@ -441,7 +441,7 @@ startup_time (std::chrono::steady_clock::now ()) // Drop unchecked blocks if initial bootstrap is completed if (!flags.disable_unchecked_drop && !use_bootstrap_weight && !flags.read_only) { - auto transaction (store.tx_begin_write ()); + auto transaction (store.tx_begin_write ({ tables::unchecked })); store.unchecked_clear (transaction); ledger.cache.unchecked_count = 0; logger.always_log ("Dropping unchecked blocks"); @@ -626,7 +626,7 @@ nano::process_return nano::node::process_local (std::shared_ptr blo // Notify block processor to release write lock block_processor.wait_write (); // Process block - auto transaction (store.tx_begin_write ()); + auto transaction (store.tx_begin_write ({ tables::accounts, tables::cached_counts, tables::change_blocks, tables::frontiers, tables::open_blocks, tables::pending, tables::receive_blocks, tables::representation, tables::send_blocks, tables::state_blocks }, { tables::confirmation_height })); return block_processor.process_one (transaction, info, work_watcher_a); } @@ -780,7 +780,7 @@ nano::uint128_t nano::node::minimum_principal_weight (nano::uint128_t const & on void nano::node::long_inactivity_cleanup () { bool perform_cleanup = false; - auto transaction (store.tx_begin_write ()); + auto transaction (store.tx_begin_write ({ tables::online_weight, tables::peers })); if (store.online_weight_count (transaction) > 0) { auto i (store.online_weight_begin (transaction)); @@ -790,7 +790,7 @@ void nano::node::long_inactivity_cleanup () { ++sample; } - assert (sample != n); + debug_assert (sample != n); auto const one_week_ago = (std::chrono::system_clock::now () - std::chrono::hours (7 * 24)).time_since_epoch ().count (); perform_cleanup = sample->first < one_week_ago; } @@ -950,14 +950,14 @@ void nano::node::unchecked_cleanup () while (!cleaning_list.empty ()) { size_t deleted_count (0); - auto transaction (store.tx_begin_write ()); + auto transaction (store.tx_begin_write ({ tables::unchecked })); while (deleted_count++ < 2 * 1024 && !cleaning_list.empty ()) { auto key (cleaning_list.front ()); cleaning_list.pop_front (); if (!store.unchecked_del (transaction, key)) { - assert (ledger.cache.unchecked_count > 0); + debug_assert (ledger.cache.unchecked_count > 0); --ledger.cache.unchecked_count; } } @@ -977,7 +977,7 @@ void nano::node::ongoing_unchecked_cleanup () int nano::node::price (nano::uint128_t const & balance_a, int amount_a) { - assert (balance_a >= amount_a * nano::Gxrb_ratio); + debug_assert (balance_a >= amount_a * nano::Gxrb_ratio); auto balance_l (balance_a); double result (0.0); for (auto i (0); i < amount_a; ++i) @@ -1054,25 +1054,25 @@ boost::optional nano::node::work_generate_blocking (nano::work_version boost::optional nano::node::work_generate_blocking (nano::block & block_a) { - assert (network_params.network.is_test_network ()); + debug_assert (network_params.network.is_test_network ()); return work_generate_blocking (block_a, network_params.network.publish_threshold); } boost::optional nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) { - assert (network_params.network.is_test_network ()); + debug_assert (network_params.network.is_test_network ()); return work_generate_blocking (nano::work_version::work_1, block_a, difficulty_a); } boost::optional nano::node::work_generate_blocking (nano::root const & root_a) { - assert (network_params.network.is_test_network ()); + debug_assert (network_params.network.is_test_network ()); return work_generate_blocking (root_a, network_params.network.publish_threshold); } boost::optional nano::node::work_generate_blocking (nano::root const & root_a, uint64_t difficulty_a) { - assert (network_params.network.is_test_network ()); + debug_assert (network_params.network.is_test_network ()); return work_generate_blocking (nano::work_version::work_1, root_a, difficulty_a); } @@ -1181,7 +1181,7 @@ class confirmed_visitor : public nano::block_visitor if (!node.store.block_exists (transaction, hash)) { node.logger.try_log (boost::str (boost::format ("Confirmed block is missing: %1%") % hash.to_string ())); - assert (false && "Confirmed block is missing"); + debug_assert (false && "Confirmed block is missing"); } else { diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 45fb429557..28661615c3 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -60,7 +60,7 @@ external_address (boost::asio::ip::address_v6{}.to_string ()) preconfigured_representatives.emplace_back ("3FE80B4BC842E82C1C18ABFEEC47EA989E63953BC82AC411F304D13833D52A56"); break; default: - assert (false); + debug_assert (false); break; } } @@ -857,7 +857,7 @@ void nano::node_config::deserialize_address (std::string const & entry_a, std::v nano::account nano::node_config::random_representative () const { - assert (!preconfigured_representatives.empty ()); + debug_assert (!preconfigured_representatives.empty ()); size_t index (nano::random_pool::generate_word32 (0, static_cast (preconfigured_representatives.size () - 1))); auto result (preconfigured_representatives[index]); return result; diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp index 7dc86f0907..11d8e0517d 100644 --- a/nano/node/online_reps.cpp +++ b/nano/node/online_reps.cpp @@ -3,8 +3,6 @@ #include #include -#include - nano::online_reps::online_reps (nano::ledger & ledger_a, nano::network_params & network_params_a, nano::uint128_t minimum_a) : ledger (ledger_a), network_params (network_params_a), @@ -28,12 +26,12 @@ void nano::online_reps::observe (nano::account const & rep_a) void nano::online_reps::sample () { - auto transaction (ledger.store.tx_begin_write ()); + auto transaction (ledger.store.tx_begin_write ({ tables::online_weight })); // Discard oldest entries while (ledger.store.online_weight_count (transaction) >= network_params.node.max_weight_samples) { auto oldest (ledger.store.online_weight_begin (transaction)); - assert (oldest != ledger.store.online_weight_end ()); + debug_assert (oldest != ledger.store.online_weight_end ()); ledger.store.online_weight_del (transaction, oldest->first); } // Calculate current active rep weight diff --git a/nano/node/payment_observer_processor.cpp b/nano/node/payment_observer_processor.cpp index d804196596..acb96f2f42 100644 --- a/nano/node/payment_observer_processor.cpp +++ b/nano/node/payment_observer_processor.cpp @@ -28,13 +28,13 @@ void nano::payment_observer_processor::observer_action (nano::account const & ac void nano::payment_observer_processor::add (nano::account const & account_a, std::shared_ptr payment_observer_a) { nano::lock_guard lock (mutex); - assert (payment_observers.find (account_a) == payment_observers.end ()); + debug_assert (payment_observers.find (account_a) == payment_observers.end ()); payment_observers[account_a] = payment_observer_a; } void nano::payment_observer_processor::erase (nano::account & account_a) { nano::lock_guard lock (mutex); - assert (payment_observers.find (account_a) != payment_observers.end ()); + debug_assert (payment_observers.find (account_a) != payment_observers.end ()); payment_observers.erase (account_a); } diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 5735226344..5e458d0df0 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -44,7 +44,7 @@ void nano::rep_crawler::validate () { auto & vote = i.second; auto & channel = i.first; - assert (channel != nullptr); + debug_assert (channel != nullptr); nano::uint128_t rep_weight = node.ledger.weight (vote->account); if (rep_weight > minimum) { @@ -59,7 +59,7 @@ void nano::rep_crawler::validate () // Update if representative channel was changed if (info.channel->get_endpoint () != channel->get_endpoint ()) { - assert (info.account == vote->account); + debug_assert (info.account == vote->account); updated_or_inserted = true; info.weight = rep_weight; info.channel = channel; @@ -166,7 +166,7 @@ void nano::rep_crawler::query (std::vector channel_a) : account (account_a), weight (weight_a), channel (channel_a) { - assert (channel != nullptr); + debug_assert (channel != nullptr); } std::reference_wrapper channel_ref () const { diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index 092e4a3698..ac54f4d89c 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -26,7 +26,7 @@ thread ([this]() { run (); }) void nano::request_aggregator::add (std::shared_ptr & channel_a, std::vector> const & hashes_roots_a) { - assert (wallets.rep_counts ().voting > 0); + debug_assert (wallets.rep_counts ().voting > 0); bool error = true; auto const endpoint (nano::transport::map_endpoint_to_v6 (channel_a->get_endpoint ())); nano::unique_lock lock (mutex); @@ -192,7 +192,7 @@ std::vector nano::request_aggregator::aggregate (nano::transac to_generate.push_back (successor); } auto successor_block (store.block_get (transaction_a, successor)); - assert (successor_block != nullptr); + debug_assert (successor_block != nullptr); nano::publish publish (successor_block); pool_a.channel->send (publish); } diff --git a/nano/node/rocksdb/rocksdb.cpp b/nano/node/rocksdb/rocksdb.cpp index 1fca537072..ce9ff1f4fd 100644 --- a/nano/node/rocksdb/rocksdb.cpp +++ b/nano/node/rocksdb/rocksdb.cpp @@ -127,7 +127,7 @@ nano::write_transaction nano::rocksdb_store::tx_begin_write (std::vectorGetName () == name); }); - assert (iter != handles_l.end ()); + debug_assert (iter != handles_l.end ()); return *iter; }; @@ -172,7 +172,7 @@ rocksdb::ColumnFamilyHandle * nano::rocksdb_store::table_to_column_family (table case tables::pending: return get_handle ("pending"); case tables::blocks_info: - assert (false); + debug_assert (false); case tables::representation: return get_handle ("representation"); case tables::unchecked: @@ -214,9 +214,9 @@ bool nano::rocksdb_store::exists (nano::transaction const & transaction_a, table int nano::rocksdb_store::del (nano::write_transaction const & transaction_a, tables table_a, nano::rocksdb_val const & key_a) { - assert (transaction_a.contains (table_a)); + debug_assert (transaction_a.contains (table_a)); // RocksDB errors when trying to delete an entry which doesn't exist. It is a pre-condition that the key exists - assert (exists (transaction_a, table_a, key_a)); + debug_assert (exists (transaction_a, table_a, key_a)); // Removing an entry so counts may need adjusting if (is_caching_counts (table_a)) @@ -230,13 +230,13 @@ int nano::rocksdb_store::del (nano::write_transaction const & transaction_a, tab bool nano::rocksdb_store::block_info_get (nano::transaction const &, nano::block_hash const &, nano::block_info &) const { // Should not be called as the RocksDB backend does not use this table - assert (false); + debug_assert (false); return true; } void nano::rocksdb_store::version_put (nano::write_transaction const & transaction_a, int version_a) { - assert (transaction_a.contains (tables::meta)); + debug_assert (transaction_a.contains (tables::meta)); nano::uint256_union version_key (1); nano::uint256_union version_value (version_a); auto status (put (transaction_a, tables::meta, version_key, nano::rocksdb_val (version_value))); @@ -245,7 +245,7 @@ void nano::rocksdb_store::version_put (nano::write_transaction const & transacti rocksdb::Transaction * nano::rocksdb_store::tx (nano::transaction const & transaction_a) const { - assert (!is_read (transaction_a)); + debug_assert (!is_read (transaction_a)); return static_cast (transaction_a.get_handle ()); } @@ -318,7 +318,7 @@ int nano::rocksdb_store::decrement (nano::write_transaction const & transaction_ int nano::rocksdb_store::put (nano::write_transaction const & transaction_a, tables table_a, nano::rocksdb_val const & key_a, nano::rocksdb_val const & value_a) { - assert (transaction_a.contains (table_a)); + debug_assert (transaction_a.contains (table_a)); auto txn = tx (transaction_a); if (is_caching_counts (table_a)) @@ -398,7 +398,7 @@ size_t nano::rocksdb_store::count (nano::transaction const & transaction_a, tabl int nano::rocksdb_store::drop (nano::write_transaction const & transaction_a, tables table_a) { - assert (transaction_a.contains (table_a)); + debug_assert (transaction_a.contains (table_a)); auto col = table_to_column_family (table_a); int status = static_cast (rocksdb::Status::Code::kOk); @@ -439,7 +439,7 @@ int nano::rocksdb_store::clear (rocksdb::ColumnFamilyHandle * column_family) // Need to add it back as we just want to clear the contents auto handle_it = std::find (handles.begin (), handles.end (), column_family); - assert (handle_it != handles.cend ()); + debug_assert (handle_it != handles.cend ()); status = db->CreateColumnFamily (get_cf_options (), name, &column_family); release_assert (status.ok ()); *handle_it = column_family; diff --git a/nano/node/rocksdb/rocksdb_iterator.hpp b/nano/node/rocksdb/rocksdb_iterator.hpp index 0110066a77..ff10f02170 100644 --- a/nano/node/rocksdb/rocksdb_iterator.hpp +++ b/nano/node/rocksdb/rocksdb_iterator.hpp @@ -18,7 +18,7 @@ inline bool is_read (nano::transaction const & transaction_a) inline rocksdb::ReadOptions const & snapshot_options (nano::transaction const & transaction_a) { - assert (is_read (transaction_a)); + debug_assert (is_read (transaction_a)); return *static_cast (transaction_a.get_handle ()); } } @@ -136,9 +136,9 @@ class rocksdb_iterator : public store_iterator_impl } auto result (std::memcmp (current.first.data (), other_a->current.first.data (), current.first.size ()) == 0); - assert (!result || (current.first.size () == other_a->current.first.size ())); - assert (!result || (current.second.data () == other_a->current.second.data ())); - assert (!result || (current.second.size () == other_a->current.second.size ())); + debug_assert (!result || (current.first.size () == other_a->current.first.size ())); + debug_assert (!result || (current.second.data () == other_a->current.second.data ())); + debug_assert (!result || (current.second.size () == other_a->current.second.size ())); return result; } @@ -172,7 +172,7 @@ class rocksdb_iterator : public store_iterator_impl { current.first = nano::rocksdb_val{}; current.second = nano::rocksdb_val{}; - assert (is_end_sentinal ()); + debug_assert (is_end_sentinal ()); } nano::rocksdb_iterator & operator= (nano::rocksdb_iterator && other_a) { diff --git a/nano/node/signatures.cpp b/nano/node/signatures.cpp index 502d250302..30f9413819 100644 --- a/nano/node/signatures.cpp +++ b/nano/node/signatures.cpp @@ -166,5 +166,5 @@ void nano::signature_checker::set_thread_names (unsigned num_threads) { future.wait (); } - assert (pending == 0); + debug_assert (pending == 0); } diff --git a/nano/node/socket.cpp b/nano/node/socket.cpp index f9cb4425ae..4e52265b1b 100644 --- a/nano/node/socket.cpp +++ b/nano/node/socket.cpp @@ -66,7 +66,7 @@ void nano::socket::async_read (std::shared_ptr> buffer_a, s } else { - assert (false && "nano::socket::async_read called with incorrect buffer size"); + debug_assert (false && "nano::socket::async_read called with incorrect buffer size"); boost::system::error_code ec_buffer = boost::system::errc::make_error_code (boost::system::errc::no_buffer_space); callback_a (ec_buffer, 0); } @@ -378,6 +378,6 @@ void nano::server_socket::on_connection (std::function #include -#include #include #include #include @@ -21,7 +20,7 @@ worker (worker_a), batch_request (std::make_shared (network, alarm, worker)) { // Before callbacks are called with the batch request, check if any of the single request data can be appended to give - batch_request->pre_callback_callback = [this](std::unordered_map & data_a, std::mutex & mutex_a) { + batch_request->pre_callback_callback = [this](std::unordered_map & datas_a, std::mutex & mutex_a) { nano::lock_guard guard (this->mutex); for (auto & single_request : single_requests) { @@ -36,7 +35,7 @@ batch_request (std::make_shared (network, alarm, worker)) } else { - data_a.emplace (single_request.first, single_request.second.impl->cached_telemetry_data.begin ()->second); + datas_a.emplace (single_request.first, single_request.second.impl->cached_telemetry_data.begin ()->second.data); } } } @@ -51,7 +50,7 @@ batch_request (std::make_shared (network, alarm, worker)) } else { - data_a.emplace (pending.first, pending.second); + datas_a.emplace (pending.first, pending.second.data); } } finished_single_requests.clear (); @@ -153,10 +152,14 @@ void nano::telemetry::ongoing_single_request_cleanup (nano::endpoint const & end if (auto telemetry_impl = telemetry_impl_w.lock ()) { nano::lock_guard guard (this->mutex); + nano::lock_guard guard_telemetry_impl (telemetry_impl->mutex); if (std::chrono::steady_clock::now () - telemetry_impl->cache_cutoff > single_request_data_a.last_updated && telemetry_impl->callbacks.empty ()) { // This will be picked up by the batch request next round - this->finished_single_requests[endpoint_a] = telemetry_impl->cached_telemetry_data.begin ()->second; + if (!telemetry_impl->cached_telemetry_data.empty ()) + { + this->finished_single_requests[endpoint_a] = telemetry_impl->cached_telemetry_data.begin ()->second; + } this->single_requests.erase (endpoint_a); } else @@ -192,7 +195,7 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptrget_network_version () >= network_params.protocol.telemetry_protocol_version_min)) { - auto add_callback_async = [& worker = this->worker, &callback_a](telemetry_data_time_pair const & telemetry_data_time_pair_a, nano::endpoint const & endpoint_a) { - telemetry_data_response telemetry_data_response_l{ telemetry_data_time_pair_a, endpoint_a, false }; + auto add_callback_async = [& worker = this->worker, &callback_a](telemetry_data const & telemetry_data_a, nano::endpoint const & endpoint_a) { + telemetry_data_response telemetry_data_response_l{ telemetry_data_a, endpoint_a, false }; worker.push_task ([telemetry_data_response_l, callback_a]() { callback_a (telemetry_data_response_l); }); @@ -214,7 +217,7 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptrcached_telemetry_data.find (channel_a->get_endpoint ()); if (it != batch_request->cached_telemetry_data.cend ()) { - add_callback_async (it->second, it->first); + add_callback_async (it->second.data, it->first); return; } } @@ -222,7 +225,7 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptrget_endpoint ()); if (it != finished_single_requests.cend ()) { - add_callback_async (it->second, it->first); + add_callback_async (it->second.data, it->first); return; } @@ -235,13 +238,13 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptrsecond, it->first, error }); } else { - callback_a ({ nano::telemetry_data_time_pair{}, channel_a->get_endpoint (), error }); + callback_a ({ nano::telemetry_data{}, channel_a->get_endpoint (), error }); } }); } @@ -334,7 +337,7 @@ void nano::telemetry_impl::get_metrics_async (std::dequeget_endpoint (); }); @@ -354,7 +357,7 @@ void nano::telemetry_impl::add (nano::telemetry_data const & telemetry_data_a, n if (!is_empty_a) { - current_telemetry_data_responses[endpoint_a] = { telemetry_data_a, std::chrono::steady_clock::now (), std::chrono::system_clock::now () }; + current_telemetry_data_responses[endpoint_a] = { telemetry_data_a, std::chrono::steady_clock::now () }; } channel_processed (lk, endpoint_a); } @@ -363,12 +366,16 @@ void nano::telemetry_impl::invoke_callbacks () { decltype (callbacks) callbacks_l; bool all_received; - decltype (cached_telemetry_data) cached_telemetry_data_l; + std::unordered_map cached_responses_l; { // Copy callbacks so that they can be called outside of holding the lock nano::lock_guard guard (mutex); callbacks_l = callbacks; - cached_telemetry_data_l = cached_telemetry_data; + cached_responses_l.reserve (cached_telemetry_data.size ()); + std::transform (cached_telemetry_data.begin (), cached_telemetry_data.end (), std::inserter (cached_responses_l, cached_responses_l.end ()), [](auto const & endpoint_telemetry_data) { + return std::pair{ endpoint_telemetry_data.first, endpoint_telemetry_data.second.data }; + }); + current_telemetry_data_responses.clear (); callbacks.clear (); all_received = failed.empty (); @@ -376,23 +383,23 @@ void nano::telemetry_impl::invoke_callbacks () if (pre_callback_callback) { - pre_callback_callback (cached_telemetry_data_l, mutex); + pre_callback_callback (cached_responses_l, mutex); } // Need to account for nodes which disable telemetry data in responses - bool all_received_l = !cached_telemetry_data_l.empty () && all_received; + bool all_received_l = !cached_responses_l.empty () && all_received; for (auto & callback : callbacks_l) { - callback ({ cached_telemetry_data_l, all_received_l }); + callback ({ cached_responses_l, all_received_l }); } } void nano::telemetry_impl::channel_processed (nano::unique_lock & lk_a, nano::endpoint const & endpoint_a) { - assert (lk_a.owns_lock ()); + debug_assert (lk_a.owns_lock ()); auto num_removed = required_responses.erase (endpoint_a); if (num_removed > 0 && required_responses.empty ()) { - assert (lk_a.owns_lock ()); + debug_assert (lk_a.owns_lock ()); cached_telemetry_data = current_telemetry_data_responses; last_time = std::chrono::steady_clock::now (); @@ -413,7 +420,7 @@ void nano::telemetry_impl::fire_request_messages (std::dequeget_network_version () >= network_params.protocol.telemetry_protocol_version_min); + debug_assert (channel->get_network_version () >= network_params.protocol.telemetry_protocol_version_min); std::weak_ptr this_w (shared_from_this ()); // clang-format off @@ -508,24 +515,14 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector telemetry_data_time_pairs; telemetry_data_time_pairs.reserve (telemetry_datas.size ()); - std::transform (telemetry_datas.begin (), telemetry_datas.end (), std::back_inserter (telemetry_data_time_pairs), [](nano::telemetry_data const & telemetry_data_a) { - // Don't care about the timestamps here - return nano::telemetry_data_time_pair{ telemetry_data_a, {}, {} }; - }); - - return consolidate_telemetry_data_time_pairs (telemetry_data_time_pairs).data; -} - -nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std::vector const & telemetry_data_time_pairs_a) -{ - if (telemetry_data_time_pairs_a.empty ()) + if (telemetry_datas.empty ()) { return {}; } - else if (telemetry_data_time_pairs_a.size () == 1) + else if (telemetry_datas.size () == 1) { // Only 1 element in the collection, so just return it. - return telemetry_data_time_pairs_a.front (); + return telemetry_datas.front (); } std::unordered_map protocol_versions; @@ -539,13 +536,12 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: std::multiset cemented_counts; std::multiset peer_counts; std::multiset unchecked_counts; - std::multiset uptime_counts; - std::multiset bandwidth_counts; - std::multiset timestamp_counts; + std::multiset uptimes; + std::multiset bandwidths; + std::multiset timestamps; - for (auto const & telemetry_data_time_pair : telemetry_data_time_pairs_a) + for (auto const & telemetry_data : telemetry_datas) { - auto & telemetry_data = telemetry_data_time_pair.data; account_counts.insert (telemetry_data.account_count); block_counts.insert (telemetry_data.block_count); cemented_counts.insert (telemetry_data.cemented_count); @@ -569,25 +565,28 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: } } + if (telemetry_data.timestamp.is_initialized ()) + { + timestamps.insert (std::chrono::duration_cast (telemetry_data.timestamp->time_since_epoch ()).count ()); + } + ++vendor_versions[ss.str ()]; ++protocol_versions[telemetry_data.protocol_version]; peer_counts.insert (telemetry_data.peer_count); unchecked_counts.insert (telemetry_data.unchecked_count); - uptime_counts.insert (telemetry_data.uptime); + uptimes.insert (telemetry_data.uptime); // 0 has a special meaning (unlimited), don't include it in the average as it will be heavily skewed if (telemetry_data.bandwidth_cap != 0) { - bandwidth_counts.insert (telemetry_data.bandwidth_cap); + bandwidths.insert (telemetry_data.bandwidth_cap); } ++bandwidth_caps[telemetry_data.bandwidth_cap]; ++genesis_blocks[telemetry_data.genesis_block]; - - timestamp_counts.insert (std::chrono::time_point_cast (telemetry_data_time_pair.system_last_updated).time_since_epoch ().count ()); } // Remove 10% of the results from the lower and upper bounds to catch any outliers. Need at least 10 responses before any are removed. - auto num_either_side_to_remove = telemetry_data_time_pairs_a.size () / 10; + auto num_either_side_to_remove = telemetry_datas.size () / 10; auto strip_outliers_and_sum = [num_either_side_to_remove](auto & counts) { counts.erase (counts.begin (), std::next (counts.begin (), num_either_side_to_remove)); @@ -602,11 +601,11 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: auto cemented_sum = strip_outliers_and_sum (cemented_counts); auto peer_sum = strip_outliers_and_sum (peer_counts); auto unchecked_sum = strip_outliers_and_sum (unchecked_counts); - auto uptime_sum = strip_outliers_and_sum (uptime_counts); - auto bandwidth_sum = strip_outliers_and_sum (bandwidth_counts); + auto uptime_sum = strip_outliers_and_sum (uptimes); + auto bandwidth_sum = strip_outliers_and_sum (bandwidths); nano::telemetry_data consolidated_data; - auto size = telemetry_data_time_pairs_a.size () - num_either_side_to_remove * 2; + auto size = telemetry_datas.size () - num_either_side_to_remove * 2; consolidated_data.account_count = boost::numeric_cast (account_sum / size); consolidated_data.block_count = boost::numeric_cast (block_sum / size); consolidated_data.cemented_count = boost::numeric_cast (cemented_sum / size); @@ -614,6 +613,12 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: consolidated_data.uptime = boost::numeric_cast (uptime_sum / size); consolidated_data.unchecked_count = boost::numeric_cast (unchecked_sum / size); + if (!timestamps.empty ()) + { + auto timestamp_sum = strip_outliers_and_sum (timestamps); + consolidated_data.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (boost::numeric_cast (timestamp_sum / timestamps.size ()))); + } + auto set_mode_or_average = [](auto const & collection, auto & var, auto const & sum, size_t size) { auto max = std::max_element (collection.begin (), collection.end (), [](auto const & lhs, auto const & rhs) { return lhs.second < rhs.second; @@ -655,7 +660,7 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: // May only have major version, but check for optional parameters as well, only output if all are used std::vector version_fragments; boost::split (version_fragments, version, boost::is_any_of (".")); - assert (!version_fragments.empty () && version_fragments.size () <= 5); + debug_assert (!version_fragments.empty () && version_fragments.size () <= 5); consolidated_data.major_version = boost::lexical_cast (version_fragments.front ()); if (version_fragments.size () == 5) { @@ -665,11 +670,7 @@ nano::telemetry_data_time_pair nano::consolidate_telemetry_data_time_pairs (std: consolidated_data.maker = boost::lexical_cast (version_fragments[4]); } - // Consolidate timestamps - auto timestamp_sum = strip_outliers_and_sum (timestamp_counts); - auto consolidated_timestamp = boost::numeric_cast (timestamp_sum / size); - - return telemetry_data_time_pair{ consolidated_data, std::chrono::steady_clock::time_point{}, std::chrono::system_clock::time_point (std::chrono::milliseconds (consolidated_timestamp)) }; + return consolidated_data; } nano::telemetry_data nano::local_telemetry_data (nano::ledger_cache const & ledger_cache_a, nano::network & network_a, uint64_t bandwidth_limit_a, nano::network_params const & network_params_a, std::chrono::steady_clock::time_point statup_time_a) @@ -689,5 +690,6 @@ nano::telemetry_data nano::local_telemetry_data (nano::ledger_cache const & ledg telemetry_data.patch_version = nano::get_patch_node_version (); telemetry_data.pre_release_version = nano::get_pre_release_node_version (); telemetry_data.maker = 0; // 0 Indicates it originated from the NF + telemetry_data.timestamp = std::chrono::system_clock::now (); return telemetry_data; } diff --git a/nano/node/telemetry.hpp b/nano/node/telemetry.hpp index 093c996bcc..4406e7cd24 100644 --- a/nano/node/telemetry.hpp +++ b/nano/node/telemetry.hpp @@ -23,7 +23,6 @@ class telemetry_data_time_pair public: nano::telemetry_data data; std::chrono::steady_clock::time_point last_updated; - std::chrono::system_clock::time_point system_last_updated; bool operator== (telemetry_data_time_pair const &) const; bool operator!= (telemetry_data_time_pair const &) const; }; @@ -34,7 +33,7 @@ class telemetry_data_time_pair class telemetry_data_response { public: - nano::telemetry_data_time_pair telemetry_data_time_pair; + nano::telemetry_data telemetry_data; nano::endpoint endpoint; bool error{ true }; }; @@ -45,7 +44,7 @@ class telemetry_data_response class telemetry_data_responses { public: - std::unordered_map telemetry_data_time_pairs; + std::unordered_map telemetry_datas; bool all_received{ false }; }; @@ -88,7 +87,7 @@ class telemetry_impl : public std::enable_shared_from_this nano::alarm & alarm; nano::worker & worker; - std::function & data_a, std::mutex &)> pre_callback_callback; + std::function & data_a, std::mutex &)> pre_callback_callback; void invoke_callbacks (); void channel_processed (nano::unique_lock & lk_a, nano::endpoint const & endpoint_a); diff --git a/nano/node/testing.cpp b/nano/node/testing.cpp index c90d820633..45c6e09290 100644 --- a/nano/node/testing.cpp +++ b/nano/node/testing.cpp @@ -30,7 +30,7 @@ std::shared_ptr nano::system::add_node (nano::node_flags node_flags_ std::shared_ptr nano::system::add_node (nano::node_config const & node_config_a, nano::node_flags node_flags_a, nano::transport::transport_type type_a) { auto node (std::make_shared (io_ctx, nano::unique_path (), alarm, node_config_a, work, node_flags_a)); - assert (!node->init_error ()); + debug_assert (!node->init_error ()); node->start (); node->wallets.create (nano::random_wallet_id ()); nodes.reserve (nodes.size () + 1); @@ -82,7 +82,7 @@ std::shared_ptr nano::system::add_node (nano::node_config const & no { poll (); ++iterations1; - assert (iterations1 < 10000); + debug_assert (iterations1 < 10000); } } else @@ -92,7 +92,7 @@ std::shared_ptr nano::system::add_node (nano::node_config const & no { poll (); ++iterations1; - assert (iterations1 < 10000); + debug_assert (iterations1 < 10000); } } @@ -143,10 +143,10 @@ nano::system::~system () std::shared_ptr nano::system::wallet (size_t index_a) { - assert (nodes.size () > index_a); + debug_assert (nodes.size () > index_a); auto size (nodes[index_a]->wallets.items.size ()); (void)size; - assert (size == 1); + debug_assert (size == 1); return nodes[index_a]->wallets.items.begin ()->second; } @@ -154,9 +154,9 @@ nano::account nano::system::account (nano::transaction const & transaction_a, si { auto wallet_l (wallet (index_a)); auto keys (wallet_l->store.begin (transaction_a)); - assert (keys != wallet_l->store.end ()); + debug_assert (keys != wallet_l->store.end ()); auto result (keys->first); - assert (++keys == wallet_l->store.end ()); + debug_assert (++keys == wallet_l->store.end ()); return nano::account (result); } @@ -219,8 +219,8 @@ void nano::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a) void nano::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a, size_t index_a) { - assert (nodes.size () > index_a); - assert (count_a > 0); + debug_assert (nodes.size () > index_a); + debug_assert (count_a > 0); auto generate (std::make_shared (count_a, wait_a, nodes[index_a], *this)); generate->run (); } @@ -228,7 +228,7 @@ void nano::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a, si void nano::system::generate_rollback (nano::node & node_a, std::vector & accounts_a) { auto transaction (node_a.store.tx_begin_write ()); - assert (std::numeric_limits::max () > accounts_a.size ()); + debug_assert (std::numeric_limits::max () > accounts_a.size ()); auto index (random_pool::generate_word32 (0, static_cast (accounts_a.size () - 1))); auto account (accounts_a[index]); nano::account_info info; @@ -244,7 +244,7 @@ void nano::system::generate_rollback (nano::node & node_a, std::vector> rollback_list; auto error = node_a.ledger.rollback (transaction, hash, rollback_list); (void)error; - assert (!error); + debug_assert (!error); for (auto & i : rollback_list) { node_a.wallets.watcher->remove (i); @@ -306,7 +306,7 @@ void nano::system::generate_activity (nano::node & node_a, std::vector & accounts_a) { - assert (std::numeric_limits::max () > accounts_a.size ()); + debug_assert (std::numeric_limits::max () > accounts_a.size ()); auto index (random_pool::generate_word32 (0, static_cast (accounts_a.size () - 1))); auto result (accounts_a[index]); return result; @@ -334,7 +334,7 @@ void nano::system::generate_send_existing (nano::node & node_a, std::vectorfirst); source = get_random_account (accounts_a); amount = get_random_amount (transaction, node_a, source); @@ -343,7 +343,7 @@ void nano::system::generate_send_existing (nano::node & node_a, std::vectorsend_sync (source, destination, amount)); (void)hash; - assert (!hash.is_zero ()); + debug_assert (!hash.is_zero ()); } } @@ -355,7 +355,7 @@ void nano::system::generate_change_known (nano::node & node_a, std::vectorchange_sync (source, destination)); (void)change_error; - assert (!change_error); + debug_assert (!change_error); } } @@ -368,13 +368,13 @@ void nano::system::generate_change_unknown (nano::node & node_a, std::vectorchange_sync (source, destination)); (void)change_error; - assert (!change_error); + debug_assert (!change_error); } } void nano::system::generate_send_new (nano::node & node_a, std::vector & accounts_a) { - assert (node_a.wallets.items.size () == 1); + debug_assert (node_a.wallets.items.size () == 1); nano::uint128_t amount; nano::account source; { @@ -388,7 +388,7 @@ void nano::system::generate_send_new (nano::node & node_a, std::vectorsend_sync (source, pub, amount)); (void)hash; - assert (!hash.is_zero ()); + debug_assert (!hash.is_zero ()); } } diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 4814bddd65..9adefb03de 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -101,7 +101,7 @@ node (node_a) bool nano::transport::tcp_channels::insert (std::shared_ptr channel_a, std::shared_ptr socket_a, std::shared_ptr bootstrap_server_a) { auto endpoint (channel_a->get_tcp_endpoint ()); - assert (endpoint.address ().is_v6 ()); + debug_assert (endpoint.address ().is_v6 ()); auto udp_endpoint (nano::transport::map_tcp_to_endpoint (endpoint)); bool error (true); if (!node.network.not_a_peer (udp_endpoint, node.config.allow_local_peers) && !stopped) @@ -182,15 +182,15 @@ std::unordered_set> nano::transport::t void nano::transport::tcp_channels::random_fill (std::array & target_a) const { auto peers (random_set (target_a.size ())); - assert (peers.size () <= target_a.size ()); + debug_assert (peers.size () <= target_a.size ()); auto endpoint (nano::endpoint (boost::asio::ip::address_v6{}, 0)); - assert (endpoint.address ().is_v6 ()); + debug_assert (endpoint.address ().is_v6 ()); std::fill (target_a.begin (), target_a.end (), endpoint); auto j (target_a.begin ()); for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i, ++j) { - assert ((*i)->get_endpoint ().address ().is_v6 ()); - assert (j < target_a.end ()); + debug_assert ((*i)->get_endpoint ().address ().is_v6 ()); + debug_assert (j < target_a.end ()); *j = (*i)->get_endpoint (); } } @@ -280,13 +280,13 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa // Add temporary channel socket_a->set_writer_concurrency (nano::socket::concurrency::multi_writer); auto temporary_channel (std::make_shared (node, socket_a)); - assert (endpoint_a == temporary_channel->get_tcp_endpoint ()); + debug_assert (endpoint_a == temporary_channel->get_tcp_endpoint ()); temporary_channel->set_node_id (node_id_a); temporary_channel->set_network_version (message_a.header.version_using); temporary_channel->set_last_packet_received (std::chrono::steady_clock::now ()); temporary_channel->set_last_packet_sent (std::chrono::steady_clock::now ()); temporary_channel->temporary = true; - assert (type_a == nano::bootstrap_server_type::realtime || type_a == nano::bootstrap_server_type::realtime_response_server); + debug_assert (type_a == nano::bootstrap_server_type::realtime || type_a == nano::bootstrap_server_type::realtime_response_server); // Don't insert temporary channels for response_server if (type_a == nano::bootstrap_server_type::realtime) { @@ -297,8 +297,8 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa else { // Initial node_id_handshake request without node ID - assert (message_a.header.type == nano::message_type::node_id_handshake); - assert (type_a == nano::bootstrap_server_type::undefined); + debug_assert (message_a.header.type == nano::message_type::node_id_handshake); + debug_assert (type_a == nano::bootstrap_server_type::undefined); node.stats.inc (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in); } } diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index c63dc2258b..de120589da 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -78,7 +78,7 @@ namespace transport class tcp_channels final { friend class nano::transport::channel_tcp; - friend class node_telemetry_simultaneous_single_and_random_requests_Test; + friend class node_telemetry_simultaneous_single_and_all_requests_Test; public: tcp_channels (nano::node &); @@ -166,7 +166,7 @@ namespace transport nano::account node_id () const { auto node_id (channel->get_node_id ()); - assert (!node_id.is_zero ()); + debug_assert (!node_id.is_zero ()); return node_id; } }; diff --git a/nano/node/transport/transport.cpp b/nano/node/transport/transport.cpp index 0922b328af..fe9f83e645 100644 --- a/nano/node/transport/transport.cpp +++ b/nano/node/transport/transport.cpp @@ -119,7 +119,7 @@ boost::asio::ip::address_v6 mapped_from_v4_bytes (unsigned long address_a) bool nano::transport::reserved_address (nano::endpoint const & endpoint_a, bool allow_local_peers) { - assert (endpoint_a.address ().is_v6 ()); + debug_assert (endpoint_a.address ().is_v6 ()); auto bytes (endpoint_a.address ().to_v6 ()); auto result (false); static auto const rfc1700_min (mapped_from_v4_bytes (0x00000000ul)); diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp index eddc5a2bca..fc355f7bf4 100644 --- a/nano/node/transport/udp.cpp +++ b/nano/node/transport/udp.cpp @@ -13,7 +13,7 @@ endpoint (endpoint_a), channels (channels_a) { set_network_version (protocol_version_a); - assert (endpoint_a.address ().is_v6 ()); + debug_assert (endpoint_a.address ().is_v6 ()); } size_t nano::transport::channel_udp::hash_code () const @@ -102,7 +102,7 @@ void nano::transport::udp_channels::send (nano::shared_const_buffer const & buff std::shared_ptr nano::transport::udp_channels::insert (nano::endpoint const & endpoint_a, unsigned network_version_a) { - assert (endpoint_a.address ().is_v6 ()); + debug_assert (endpoint_a.address ().is_v6 ()); std::shared_ptr result; if (!node.network.not_a_peer (endpoint_a, node.config.allow_local_peers) && (node.network_params.network.is_test_network () || !max_ip_connections (endpoint_a))) { @@ -176,15 +176,15 @@ std::unordered_set> nano::transport::u void nano::transport::udp_channels::random_fill (std::array & target_a) const { auto peers (random_set (target_a.size ())); - assert (peers.size () <= target_a.size ()); + debug_assert (peers.size () <= target_a.size ()); auto endpoint (nano::endpoint (boost::asio::ip::address_v6{}, 0)); - assert (endpoint.address ().is_v6 ()); + debug_assert (endpoint.address ().is_v6 ()); std::fill (target_a.begin (), target_a.end (), endpoint); auto j (target_a.begin ()); for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i, ++j) { - assert ((*i)->get_endpoint ().address ().is_v6 ()); - assert (j < target_a.end ()); + debug_assert ((*i)->get_endpoint ().address ().is_v6 ()); + debug_assert (j < target_a.end ()); *j = (*i)->get_endpoint (); } } @@ -316,7 +316,7 @@ void nano::transport::udp_channels::receive () void nano::transport::udp_channels::start () { - assert (!node.flags.disable_udp); + debug_assert (!node.flags.disable_udp); for (size_t i = 0; i < node.config.io_threads && !stopped; ++i) { boost::asio::post (strand, [this]() { @@ -419,19 +419,19 @@ class udp_message_visitor : public nano::message_visitor } void bulk_pull (nano::bulk_pull const &) override { - assert (false); + debug_assert (false); } void bulk_pull_account (nano::bulk_pull_account const &) override { - assert (false); + debug_assert (false); } void bulk_push (nano::bulk_push const &) override { - assert (false); + debug_assert (false); } void frontier_req (nano::frontier_req const &) override { - assert (false); + debug_assert (false); } void telemetry_req (nano::telemetry_req const & message_a) override { diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 4d64aeefda..2f2cb19d39 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -166,7 +166,7 @@ void nano::vote_processor::verify_votes (decltype (votes) const & votes_a) auto i (0); for (auto const & vote : votes_a) { - assert (verifications[i] == 1 || verifications[i] == 0); + debug_assert (verifications[i] == 1 || verifications[i] == 0); if (verifications[i] == 1) { vote_blocking (vote.first, vote.second, true); diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index 261b0c17c0..f60c790168 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -111,7 +111,7 @@ void nano::votes_cache::add (std::shared_ptr const & vote_a) { nano::lock_guard lock (cache_mutex); auto voting (wallets.rep_counts ().voting); - assert (voting > 0); + debug_assert (voting > 0); auto const max_cache_size (network_params.voting.max_cache / std::max (voting, static_cast (1))); for (auto & block : vote_a->blocks) { @@ -127,7 +127,7 @@ void nano::votes_cache::add (std::shared_ptr const & vote_a) // Insert new votes (new hash) auto inserted (cache.get ().emplace_back (nano::cached_votes{ hash, std::vector> (1, vote_a) })); (void)inserted; - assert (inserted.second); + debug_assert (inserted.second); } else { diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 3fb2842aa5..18cfd8cdc7 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -88,7 +88,7 @@ nano::public_key nano::wallet_store::deterministic_insert (nano::transaction con nano::private_key nano::wallet_store::deterministic_key (nano::transaction const & transaction_a, uint32_t index_a) { - assert (valid_password (transaction_a)); + debug_assert (valid_password (transaction_a)); nano::raw_key seed_l; seed (seed_l, transaction_a); return nano::deterministic_key (seed_l, index_a); @@ -166,7 +166,7 @@ bool nano::wallet_store::attempt_password (nano::transaction const & transaction case version_4: break; default: - assert (false); + debug_assert (false); } } return result; @@ -226,7 +226,7 @@ void nano::fan::value (nano::raw_key & prv_a) void nano::fan::value_get (nano::raw_key & prv_a) { - assert (!mutex.try_lock ()); + debug_assert (!mutex.try_lock ()); prv_a.data.clear (); for (auto & i : values) { @@ -271,7 +271,7 @@ kdf (kdf_a) if (!init_a) { MDB_val junk; - assert (mdb_get (tx (transaction_a), handle, nano::mdb_val (version_special), &junk) == MDB_NOTFOUND); + debug_assert (mdb_get (tx (transaction_a), handle, nano::mdb_val (version_special), &junk) == MDB_NOTFOUND); boost::property_tree::ptree wallet_l; std::stringstream istream (json_a); try @@ -378,7 +378,7 @@ std::vector nano::wallet_store::accounts (nano::transaction const void nano::wallet_store::initialize (nano::transaction const & transaction_a, bool & init_a, std::string const & path_a) { - assert (strlen (path_a.c_str ()) == path_a.size ()); + debug_assert (strlen (path_a.c_str ()) == path_a.size ()); auto error (0); error |= mdb_dbi_open (tx (transaction_a), path_a.c_str (), MDB_CREATE, &handle); init_a = error != 0; @@ -402,7 +402,7 @@ nano::account nano::wallet_store::representative (nano::transaction const & tran nano::public_key nano::wallet_store::insert_adhoc (nano::transaction const & transaction_a, nano::raw_key const & prv) { - assert (valid_password (transaction_a)); + debug_assert (valid_password (transaction_a)); nano::public_key pub (nano::pub_key (prv.as_private_key ())); nano::raw_key password_l; wallet_key (password_l, transaction_a); @@ -426,7 +426,7 @@ void nano::wallet_store::erase (nano::transaction const & transaction_a, nano::a { auto status (mdb_del (tx (transaction_a), handle, nano::mdb_val (pub), nullptr)); (void)status; - assert (status == 0); + debug_assert (status == 0); } nano::wallet_value nano::wallet_store::entry_get_raw (nano::transaction const & transaction_a, nano::account const & pub_a) @@ -450,7 +450,7 @@ void nano::wallet_store::entry_put_raw (nano::transaction const & transaction_a, { auto status (mdb_put (tx (transaction_a), handle, nano::mdb_val (pub_a), nano::mdb_val (sizeof (entry_a), const_cast (&entry_a)), 0)); (void)status; - assert (status == 0); + debug_assert (status == 0); } nano::key_type nano::wallet_store::key_type (nano::wallet_value const & value_a) @@ -569,8 +569,8 @@ void nano::wallet_store::write_backup (nano::transaction const & transaction_a, bool nano::wallet_store::move (nano::transaction const & transaction_a, nano::wallet_store & other_a, std::vector const & keys) { - assert (valid_password (transaction_a)); - assert (other_a.valid_password (transaction_a)); + debug_assert (valid_password (transaction_a)); + debug_assert (other_a.valid_password (transaction_a)); auto result (false); for (auto i (keys.begin ()), n (keys.end ()); i != n; ++i) { @@ -588,8 +588,8 @@ bool nano::wallet_store::move (nano::transaction const & transaction_a, nano::wa bool nano::wallet_store::import (nano::transaction const & transaction_a, nano::wallet_store & other_a) { - assert (valid_password (transaction_a)); - assert (other_a.valid_password (transaction_a)); + debug_assert (valid_password (transaction_a)); + debug_assert (other_a.valid_password (transaction_a)); auto result (false); for (auto i (other_a.begin (transaction_a)), n (end ()); i != n; ++i) { @@ -630,7 +630,7 @@ bool nano::wallet_store::work_get (nano::transaction const & transaction_a, nano void nano::wallet_store::work_put (nano::transaction const & transaction_a, nano::public_key const & pub_a, uint64_t work_a) { auto entry (entry_get_raw (transaction_a, pub_a)); - assert (!entry.key.is_zero ()); + debug_assert (!entry.key.is_zero ()); entry.work = work_a; entry_put_raw (transaction_a, pub_a, entry); } @@ -651,7 +651,7 @@ void nano::wallet_store::version_put (nano::transaction const & transaction_a, u void nano::wallet_store::upgrade_v1_v2 (nano::transaction const & transaction_a) { - assert (version (transaction_a) == 1); + debug_assert (version (transaction_a) == 1); nano::raw_key zero_password; nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::wallet_key_special)); nano::raw_key kdf; @@ -694,7 +694,7 @@ void nano::wallet_store::upgrade_v1_v2 (nano::transaction const & transaction_a) void nano::wallet_store::upgrade_v2_v3 (nano::transaction const & transaction_a) { - assert (version (transaction_a) == 2); + debug_assert (version (transaction_a) == 2); nano::raw_key seed; random_pool::generate_block (seed.data.bytes.data (), seed.data.bytes.size ()); seed_set (transaction_a, seed); @@ -704,9 +704,9 @@ void nano::wallet_store::upgrade_v2_v3 (nano::transaction const & transaction_a) void nano::wallet_store::upgrade_v3_v4 (nano::transaction const & transaction_a) { - assert (version (transaction_a) == 3); + debug_assert (version (transaction_a) == 3); version_put (transaction_a, 4); - assert (valid_password (transaction_a)); + debug_assert (valid_password (transaction_a)); nano::raw_key seed; nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::seed_special)); nano::raw_key password_l; @@ -739,7 +739,7 @@ void nano::wallet_store::upgrade_v3_v4 (nano::transaction const & transaction_a) case nano::key_type::deterministic: break; default: - assert (false); + debug_assert (false); } } } @@ -750,7 +750,7 @@ void nano::kdf::phs (nano::raw_key & result_a, std::string const & password_a, n static nano::network_params network_params; nano::lock_guard lock (mutex); auto success (argon2_hash (1, network_params.kdf_work, 1, password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), result_a.data.bytes.data (), result_a.data.bytes.size (), NULL, 0, Argon2_d, 0x10)); - assert (success == 0); + debug_assert (success == 0); (void)success; } @@ -924,7 +924,7 @@ void nano::wallet_store::destroy (nano::transaction const & transaction_a) { auto status (mdb_drop (tx (transaction_a), handle, 1)); (void)status; - assert (status == 0); + debug_assert (status == 0); handle = 0; } @@ -1006,11 +1006,11 @@ std::shared_ptr nano::wallet::change_action (nano::account const & nano::account_info info; auto error1 (wallets.node.ledger.store.account_get (block_transaction, source_a, info)); (void)error1; - assert (!error1); + debug_assert (!error1); nano::raw_key prv; auto error2 (store.fetch (transaction, source_a, prv)); (void)error2; - assert (!error2); + debug_assert (!error2); if (work_a == 0) { store.work_get (transaction, source_a, work_a); @@ -1075,11 +1075,11 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so nano::account_info info; auto error1 (wallets.node.ledger.store.account_get (block_transaction, source_a, info)); (void)error1; - assert (!error1); + debug_assert (!error1); nano::raw_key prv; auto error2 (store.fetch (transaction, source_a, prv)); (void)error2; - assert (!error2); + debug_assert (!error2); if (work_a == 0) { store.work_get (transaction, source_a, work_a); @@ -1217,8 +1217,8 @@ void nano::wallet::send_async (nano::account const & source_a, nano::account con // Update work for account if latest root is root_a void nano::wallet::work_update (nano::transaction const & transaction_a, nano::account const & account_a, nano::root const & root_a, uint64_t work_a) { - assert (!nano::work_validate (nano::work_version::work_1, root_a, work_a)); - assert (store.exists (transaction_a, account_a)); + debug_assert (!nano::work_validate (nano::work_version::work_1, root_a, work_a)); + debug_assert (store.exists (transaction_a, account_a)); auto block_transaction (wallets.node.store.tx_begin_read ()); auto latest (wallets.node.ledger.latest_root (block_transaction, account_a)); if (latest == root_a) @@ -1547,7 +1547,7 @@ thread ([this]() { auto status (mdb_dbi_open (env.tx (transaction), nullptr, MDB_CREATE, &handle)); split_if_needed (transaction, node.store); status |= mdb_dbi_open (env.tx (transaction), "send_action_ids", MDB_CREATE, &send_action_ids); - assert (status == 0); + debug_assert (status == 0); std::string beginning (nano::uint256_union (0).to_string ()); std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ()); nano::store_iterator, nano::no_value> i (std::make_unique, nano::no_value>> (transaction, handle, nano::mdb_val (beginning.size (), const_cast (beginning.c_str ())))); @@ -1557,8 +1557,8 @@ thread ([this]() { nano::wallet_id id; std::string text (i->first.data (), i->first.size ()); auto error (id.decode_hex (text)); - assert (!error); - assert (items.find (id) == items.end ()); + debug_assert (!error); + debug_assert (items.find (id) == items.end ()); auto wallet (std::make_shared (error, transaction, *this, text)); if (!error) { @@ -1622,7 +1622,7 @@ std::shared_ptr nano::wallets::open (nano::wallet_id const & id_a) std::shared_ptr nano::wallets::create (nano::wallet_id const & id_a) { nano::lock_guard lock (mutex); - assert (items.find (id_a) == items.end ()); + debug_assert (items.find (id_a) == items.end ()); std::shared_ptr result; bool error; { @@ -1667,7 +1667,7 @@ void nano::wallets::destroy (nano::wallet_id const & id_a) // action_mutex should be after transactions to prevent deadlocks in deterministic_insert () & insert_adhoc () nano::lock_guard action_lock (action_mutex); auto existing (items.find (id_a)); - assert (existing != items.end ()); + debug_assert (existing != items.end ()); auto wallet (existing->second); items.erase (existing); wallet->store.destroy (transaction); @@ -1687,7 +1687,7 @@ void nano::wallets::reload () nano::wallet_id id; std::string text (i->first.data (), i->first.size ()); auto error (id.decode_hex (text)); - assert (!error); + debug_assert (!error); // New wallet if (items.find (id) == items.end ()) { @@ -1711,7 +1711,7 @@ void nano::wallets::reload () } for (auto & i : deleted_items) { - assert (items.find (i) == items.end ()); + debug_assert (items.find (i) == items.end ()); items.erase (i); } } @@ -1751,7 +1751,7 @@ void nano::wallets::foreach_representative (std::functionfirst.data (), i->first.size ()); auto error1 (id.decode_hex (text)); (void)error1; - assert (!error1); - assert (strlen (text.c_str ()) == text.size ()); + debug_assert (!error1); + debug_assert (strlen (text.c_str ()) == text.size ()); move_table (text, tx_source, tx_destination); } } @@ -1924,15 +1924,15 @@ void nano::wallets::move_table (std::string const & name_a, MDB_txn * tx_source, MDB_dbi handle_source; auto error2 (mdb_dbi_open (tx_source, name_a.c_str (), MDB_CREATE, &handle_source)); (void)error2; - assert (!error2); + debug_assert (!error2); MDB_dbi handle_destination; auto error3 (mdb_dbi_open (tx_destination, name_a.c_str (), MDB_CREATE, &handle_destination)); (void)error3; - assert (!error3); + debug_assert (!error3); MDB_cursor * cursor; auto error4 (mdb_cursor_open (tx_source, handle_source, &cursor)); (void)error4; - assert (!error4); + debug_assert (!error4); MDB_val val_key; MDB_val val_value; auto cursor_status (mdb_cursor_get (cursor, &val_key, &val_value, MDB_FIRST)); @@ -1940,12 +1940,12 @@ void nano::wallets::move_table (std::string const & name_a, MDB_txn * tx_source, { auto error5 (mdb_put (tx_destination, handle_destination, &val_key, &val_value, 0)); (void)error5; - assert (!error5); + debug_assert (!error5); cursor_status = mdb_cursor_get (cursor, &val_key, &val_value, MDB_NEXT); } auto error6 (mdb_drop (tx_source, handle_source, 1)); (void)error6; - assert (!error6); + debug_assert (!error6); } nano::uint128_t const nano::wallets::generate_priority = std::numeric_limits::max (); diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index 8b2134571a..7bfb1e74da 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -118,7 +118,7 @@ bool nano::websocket::confirmation_options::should_filter (nano::websocket::mess auto decode_destination_ok_l (!destination_l.decode_account (destination_opt_l.get ())); (void)decode_source_ok_l; (void)decode_destination_ok_l; - assert (decode_source_ok_l && decode_destination_ok_l); + debug_assert (decode_source_ok_l && decode_destination_ok_l); if (wallets.exists (transaction_l, source_l) || wallets.exists (transaction_l, destination_l)) { should_filter_account = false; @@ -624,7 +624,7 @@ void nano::websocket::listener::broadcast_confirmation (std::shared_ptrwrite (include_block ? msg_with_block.get () : msg_without_block.get ()); @@ -749,7 +749,7 @@ nano::websocket::message nano::websocket::message_builder::vote_received (std::s vote_type = "indeterminate"; break; case nano::vote_code::invalid: - assert (false); + debug_assert (false); break; } vote_node_l.put ("type", vote_type); diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 38019d0810..d179eafa2d 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -43,7 +43,7 @@ void show_button_success (QPushButton & button) bool nano_qt::eventloop_processor::event (QEvent * event_a) { - assert (dynamic_cast (event_a) != nullptr); + debug_assert (dynamic_cast (event_a) != nullptr); static_cast (event_a)->action (); return true; } @@ -163,7 +163,7 @@ wallet (wallet_a) { auto error (this->wallet.account.decode_account (model->item (selection[0].row (), 1)->text ().toStdString ())); (void)error; - assert (!error); + debug_assert (!error); this->wallet.refresh (); } }); @@ -599,7 +599,7 @@ void nano_qt::history::refresh () { QList items; auto block (ledger.store.block_get (transaction, hash)); - assert (block != nullptr); + debug_assert (block != nullptr); block->visit (visitor); items.push_back (new QStandardItem (QString (visitor.type.c_str ()))); items.push_back (new QStandardItem (QString (visitor.account.to_account ().c_str ()))); @@ -868,7 +868,7 @@ wallet (wallet_a) void nano_qt::status::erase (nano_qt::status_types status_a) { - assert (status_a != nano_qt::status_types::nominal); + debug_assert (status_a != nano_qt::status_types::nominal); auto erased (active.erase (status_a)); (void)erased; set_text (); @@ -876,7 +876,7 @@ void nano_qt::status::erase (nano_qt::status_types status_a) void nano_qt::status::insert (nano_qt::status_types status_a) { - assert (status_a != nano_qt::status_types::nominal); + debug_assert (status_a != nano_qt::status_types::nominal); active.insert (status_a); set_text (); } @@ -889,7 +889,7 @@ void nano_qt::status::set_text () std::string nano_qt::status::text () { - assert (!active.empty ()); + debug_assert (!active.empty ()); std::string result; size_t unchecked (0); std::string count_string; @@ -923,7 +923,7 @@ std::string nano_qt::status::text () result = "Status: Running"; break; default: - assert (false); + debug_assert (false); break; } @@ -939,7 +939,7 @@ std::string nano_qt::status::text () std::string nano_qt::status::color () { - assert (!active.empty ()); + debug_assert (!active.empty ()); std::string result; switch (*active.begin ()) { @@ -965,7 +965,7 @@ std::string nano_qt::status::color () result = "color: black"; break; default: - assert (false); + debug_assert (false); break; } return result; @@ -1387,7 +1387,7 @@ void nano_qt::wallet::refresh () { { auto transaction (wallet_m->wallets.tx_begin_read ()); - assert (wallet_m->store.exists (transaction, account)); + debug_assert (wallet_m->store.exists (transaction, account)); } self.account_text->setText (QString (account.to_account ().c_str ())); needs_balance_refresh = true; @@ -1603,7 +1603,7 @@ wallet (wallet_a) } }); QObject::connect (back, &QPushButton::released, [this]() { - assert (this->wallet.main_stack->currentWidget () == window); + debug_assert (this->wallet.main_stack->currentWidget () == window); this->wallet.pop_main_stack (); }); QObject::connect (lock_toggle, &QPushButton::released, [this]() { @@ -1843,7 +1843,7 @@ wallet (wallet_a) }); auto selected_ratio_id (QSettings ().value (saved_ratio_key, ratio_group->id (mnano_unit)).toInt ()); auto selected_ratio_button = ratio_group->button (selected_ratio_id); - assert (selected_ratio_button != nullptr); + debug_assert (selected_ratio_button != nullptr); if (selected_ratio_button) { @@ -2120,7 +2120,7 @@ wallet (wallet_a) create_open (); break; default: - assert (false); + debug_assert (false); break; } }); @@ -2227,7 +2227,7 @@ void nano_qt::block_creation::create_send () nano::account_info info; auto error (wallet.node.store.account_get (block_transaction, account_l, info)); (void)error; - assert (!error); + debug_assert (!error); nano::state_block send (account_l, info.head, info.representative, balance - amount_l.number (), destination_l, key, account_l, 0); if (wallet.node.work_generate_blocking (nano::work_version::work_1, send).is_initialized ()) { diff --git a/nano/qt_system/entry.cpp b/nano/qt_system/entry.cpp index e62356c4ef..59b0c74e23 100644 --- a/nano/qt_system/entry.cpp +++ b/nano/qt_system/entry.cpp @@ -43,7 +43,7 @@ int main (int argc, char ** argv) catch (...) { result = -1; - assert (false); + debug_assert (false); } runner.join (); return result; diff --git a/nano/rpc/rpc_connection.cpp b/nano/rpc/rpc_connection.cpp index f02960afaa..6cb1108b8a 100644 --- a/nano/rpc/rpc_connection.cpp +++ b/nano/rpc/rpc_connection.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -51,7 +52,7 @@ void nano::rpc_connection::write_result (std::string body, unsigned version, boo } else { - assert (false && "RPC already responded and should only respond once"); + debug_assert (false && "RPC already responded and should only respond once"); } } diff --git a/nano/rpc/rpc_handler.cpp b/nano/rpc/rpc_handler.cpp index c4c60c5724..48979fac13 100644 --- a/nano/rpc/rpc_handler.cpp +++ b/nano/rpc/rpc_handler.cpp @@ -112,7 +112,7 @@ void nano::rpc_handler::process_request (nano::rpc_handler_request_params const } else { - assert (false); + debug_assert (false); json_error_response (response, "Invalid RPC version"); } } diff --git a/nano/rpc/rpc_secure.cpp b/nano/rpc/rpc_secure.cpp index 0e27844d35..2b81165b0f 100644 --- a/nano/rpc/rpc_secure.cpp +++ b/nano/rpc/rpc_secure.cpp @@ -113,7 +113,7 @@ void nano::rpc_secure::accept () { auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface, this->ssl_context)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection](boost::system::error_code const & ec) { - if (acceptor.is_open ()) + if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { accept (); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index c01b1b9671..52dee8be2e 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -5106,7 +5106,7 @@ TEST (rpc, blocks_info) nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); rpc.start (); - auto check_blocks = [&system, node](test_response & response) { + auto check_blocks = [node](test_response & response) { for (auto & blocks : response.json.get_child ("blocks")) { std::string hash_text (blocks.first); @@ -6277,7 +6277,7 @@ TEST (rpc, confirmation_history) ASSERT_EQ (block->hash ().to_string (), hash); nano::amount tally_num; tally_num.decode_dec (tally); - assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::Gxrb_ratio)); + debug_assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::Gxrb_ratio)); system.stop (); } @@ -6325,7 +6325,7 @@ TEST (rpc, confirmation_history_hash) ASSERT_EQ (send2->hash ().to_string (), hash); nano::amount tally_num; tally_num.decode_dec (tally); - assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::Gxrb_ratio) || tally_num == (nano::genesis_amount - 2 * nano::Gxrb_ratio) || tally_num == (nano::genesis_amount - 3 * nano::Gxrb_ratio)); + debug_assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::Gxrb_ratio) || tally_num == (nano::genesis_amount - 2 * nano::Gxrb_ratio) || tally_num == (nano::genesis_amount - 3 * nano::Gxrb_ratio)); system.stop (); } diff --git a/nano/secure/blockstore.cpp b/nano/secure/blockstore.cpp index d82df471cc..909dd2313e 100644 --- a/nano/secure/blockstore.cpp +++ b/nano/secure/blockstore.cpp @@ -166,7 +166,7 @@ is_v14_upgrade (is_v14_upgrade_a) void nano::summation_visitor::send_block (nano::send_block const & block_a) { - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) { sum_set (block_a.hashables.balance.number ()); @@ -182,7 +182,7 @@ void nano::summation_visitor::send_block (nano::send_block const & block_a) void nano::summation_visitor::state_block (nano::state_block const & block_a) { - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); sum_set (block_a.hashables.balance.number ()); if (current->type == summation_type::amount) { @@ -197,7 +197,7 @@ void nano::summation_visitor::state_block (nano::state_block const & block_a) void nano::summation_visitor::receive_block (nano::receive_block const & block_a) { - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) { current->amount_hash = block_a.hashables.source; @@ -220,7 +220,7 @@ void nano::summation_visitor::receive_block (nano::receive_block const & block_a void nano::summation_visitor::open_block (nano::open_block const & block_a) { - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) { if (block_a.hashables.source != network_params.ledger.genesis_account) @@ -242,7 +242,7 @@ void nano::summation_visitor::open_block (nano::open_block const & block_a) void nano::summation_visitor::change_block (nano::change_block const & block_a) { - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) { sum_set (0); @@ -296,7 +296,7 @@ nano::uint128_t nano::summation_visitor::compute_internal (nano::summation_visit while (!frames.empty ()) { current = &frames.top (); - assert (current->type != summation_type::invalid && current != nullptr); + debug_assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::balance) { @@ -318,7 +318,7 @@ nano::uint128_t nano::summation_visitor::compute_internal (nano::summation_visit else { auto block (block_get (transaction, current->balance_hash)); - assert (block != nullptr); + debug_assert (block != nullptr); block->visit (*this); } } @@ -351,7 +351,7 @@ nano::uint128_t nano::summation_visitor::compute_internal (nano::summation_visit } else { - assert (false); + debug_assert (false); sum_set (0); current->amount_hash = 0; } @@ -413,7 +413,7 @@ void nano::representative_visitor::compute (nano::block_hash const & hash_a) while (result.is_zero ()) { auto block (store.block_get (transaction, current)); - assert (block != nullptr); + debug_assert (block != nullptr); block->visit (*this); } } @@ -475,7 +475,7 @@ impl (std::move (write_transaction_impl)) /* * For IO threads, we do not want them to block on creating write transactions. */ - assert (nano::thread_role::get () != nano::thread_role::name::io); + debug_assert (nano::thread_role::get () != nano::thread_role::name::io); } void * nano::write_transaction::get_handle () const diff --git a/nano/secure/blockstore.hpp b/nano/secure/blockstore.hpp index 2c5f8a3573..66ac7e8d52 100644 --- a/nano/secure/blockstore.hpp +++ b/nano/secure/blockstore.hpp @@ -185,7 +185,7 @@ class db_val explicit operator nano::account_info () const { nano::account_info result; - assert (size () == result.db_size ()); + debug_assert (size () == result.db_size ()); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); return result; } @@ -193,7 +193,7 @@ class db_val explicit operator nano::account_info_v13 () const { nano::account_info_v13 result; - assert (size () == result.db_size ()); + debug_assert (size () == result.db_size ()); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); return result; } @@ -201,7 +201,7 @@ class db_val explicit operator nano::account_info_v14 () const { nano::account_info_v14 result; - assert (size () == result.db_size ()); + debug_assert (size () == result.db_size ()); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); return result; } @@ -209,7 +209,7 @@ class db_val explicit operator nano::block_info () const { nano::block_info result; - assert (size () == sizeof (result)); + debug_assert (size () == sizeof (result)); static_assert (sizeof (nano::block_info::account) + sizeof (nano::block_info::balance) == sizeof (result), "Packed class"); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), reinterpret_cast (&result)); return result; @@ -218,7 +218,7 @@ class db_val explicit operator nano::pending_info_v14 () const { nano::pending_info_v14 result; - assert (size () == result.db_size ()); + debug_assert (size () == result.db_size ()); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); return result; } @@ -226,7 +226,7 @@ class db_val explicit operator nano::pending_info () const { nano::pending_info result; - assert (size () == result.db_size ()); + debug_assert (size () == result.db_size ()); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); return result; } @@ -234,7 +234,7 @@ class db_val explicit operator nano::pending_key () const { nano::pending_key result; - assert (size () == sizeof (result)); + debug_assert (size () == sizeof (result)); static_assert (sizeof (nano::pending_key::account) + sizeof (nano::pending_key::hash) == sizeof (result), "Packed class"); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), reinterpret_cast (&result)); return result; @@ -246,7 +246,7 @@ class db_val nano::confirmation_height_info result; bool error (result.deserialize (stream)); (void)error; - assert (!error); + debug_assert (!error); return result; } @@ -256,14 +256,14 @@ class db_val nano::unchecked_info result; bool error (result.deserialize (stream)); (void)error; - assert (!error); + debug_assert (!error); return result; } explicit operator nano::unchecked_key () const { nano::unchecked_key result; - assert (size () == sizeof (result)); + debug_assert (size () == sizeof (result)); static_assert (sizeof (nano::unchecked_key::previous) + sizeof (nano::pending_key::hash) == sizeof (result), "Packed class"); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), reinterpret_cast (&result)); return result; @@ -300,7 +300,7 @@ class db_val std::array result; auto error = nano::try_read (stream, result); (void)error; - assert (!error); + debug_assert (!error); return result; } @@ -320,11 +320,11 @@ class db_val auto error (false); T block_w_sideband; block_w_sideband.state_block = std::make_shared (error, stream); - assert (!error); + debug_assert (!error); block_w_sideband.sideband.type = nano::block_type::state; error = block_w_sideband.sideband.deserialize (stream); - assert (!error); + debug_assert (!error); return block_w_sideband; } @@ -358,7 +358,7 @@ class db_val nano::bufferstream stream (reinterpret_cast (data ()), size ()); auto error (false); auto result (std::make_shared (error, stream)); - assert (!error); + debug_assert (!error); return result; } @@ -392,7 +392,7 @@ class db_val nano::bufferstream stream (reinterpret_cast (data ()), size ()); auto error (false); auto result (nano::make_shared (error, stream)); - assert (!error); + debug_assert (!error); return result; } @@ -402,7 +402,7 @@ class db_val nano::bufferstream stream (reinterpret_cast (data ()), size ()); auto error (nano::try_read (stream, result)); (void)error; - assert (!error); + debug_assert (!error); boost::endian::big_to_native_inplace (result); return result; } @@ -432,7 +432,7 @@ class db_val T convert () const { T result; - assert (size () == sizeof (result)); + debug_assert (size () == sizeof (result)); std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), result.bytes.data ()); return result; } diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp index 33f9b806c7..6e837aacab 100644 --- a/nano/secure/blockstore_partial.hpp +++ b/nano/secure/blockstore_partial.hpp @@ -30,7 +30,7 @@ class block_store_partial : public block_store void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::ledger_cache & ledger_cache_a) override { auto hash_l (genesis_a.hash ()); - assert (latest_begin (transaction_a) == latest_end ()); + debug_assert (latest_begin (transaction_a) == latest_end ()); nano::block_sideband sideband (nano::block_type::open, network_params.ledger.genesis_account, 0, network_params.ledger.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false); block_put (transaction_a, hash_l, *genesis_a.open, sideband); ++ledger_cache_a.block_count; @@ -99,8 +99,8 @@ class block_store_partial : public block_store void block_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, nano::block const & block_a, nano::block_sideband const & sideband_a) override { - assert (block_a.type () == sideband_a.type); - assert (sideband_a.successor.is_zero () || block_exists (transaction_a, sideband_a.successor)); + debug_assert (block_a.type () == sideband_a.type); + debug_assert (sideband_a.successor.is_zero () || block_exists (transaction_a, sideband_a.successor)); std::vector vector; { nano::vectorstream stream (vector); @@ -110,7 +110,7 @@ class block_store_partial : public block_store block_raw_put (transaction_a, vector, block_a.type (), hash_a); nano::block_predecessor_set predecessor (transaction_a, *this); block_a.visit (predecessor); - assert (block_a.previous ().is_zero () || block_successor (transaction_a, block_a.previous ()) == hash_a); + debug_assert (block_a.previous ().is_zero () || block_successor (transaction_a, block_a.previous ()) == hash_a); } // Converts a block hash to a block height @@ -118,7 +118,7 @@ class block_store_partial : public block_store { nano::block_sideband sideband; auto block = block_get (transaction_a, hash_a, &sideband); - assert (block != nullptr); + debug_assert (block != nullptr); return sideband.height; } @@ -131,7 +131,7 @@ class block_store_partial : public block_store { nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); result = nano::deserialize_block (stream, type); - assert (result != nullptr); + debug_assert (result != nullptr); if (sideband_a) { sideband_a->type = type; @@ -139,7 +139,7 @@ class block_store_partial : public block_store { auto error (sideband_a->deserialize (stream)); (void)error; - assert (!error); + debug_assert (!error); } else { @@ -193,7 +193,7 @@ class block_store_partial : public block_store { result = sideband.account; } - assert (!result.is_zero ()); + debug_assert (!result.is_zero ()); return result; } @@ -228,11 +228,11 @@ class block_store_partial : public block_store nano::block_hash result; if (value.size () != 0) { - assert (value.size () >= result.bytes.size ()); + debug_assert (value.size () >= result.bytes.size ()); nano::bufferstream stream (reinterpret_cast (value.data ()) + block_successor_offset (transaction_a, value.size (), type), result.bytes.size ()); auto error (nano::try_read (stream, result.bytes)); (void)error; - assert (!error); + debug_assert (!error); } else { @@ -250,7 +250,7 @@ class block_store_partial : public block_store { nano::block_type type; auto value (block_raw_get (transaction_a, hash_a, type)); - assert (value.size () != 0); + debug_assert (value.size () != 0); std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); std::fill_n (data.begin () + block_successor_offset (transaction_a, value.size (), type), sizeof (nano::block_hash), uint8_t{ 0 }); block_raw_put (transaction_a, data, type, hash_a); @@ -265,7 +265,7 @@ class block_store_partial : public block_store std::shared_ptr vote_current (nano::transaction const & transaction_a, nano::account const & account_a) override { - assert (!cache_mutex.try_lock ()); + debug_assert (!cache_mutex.try_lock ()); std::shared_ptr result; auto existing (vote_cache_l1.find (account_a)); auto have_existing (true); @@ -382,7 +382,7 @@ class block_store_partial : public block_store table = tables::state_blocks; break; default: - assert (false); + debug_assert (false); } auto status = del (transaction_a, table, hash_a); @@ -398,7 +398,7 @@ class block_store_partial : public block_store if (!not_found (status)) { nano::uint256_union version_value (data); - assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); + debug_assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); result = version_value.number ().convert_to (); } return result; @@ -501,7 +501,7 @@ class block_store_partial : public block_store if (success (status)) { std::shared_ptr result (value); - assert (result != nullptr); + debug_assert (result != nullptr); return result; } return nullptr; @@ -543,7 +543,7 @@ class block_store_partial : public block_store void account_put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::account_info const & info_a) override { // Check we are still in sync with other tables - assert (confirmation_height_exists (transaction_a, account_a)); + debug_assert (confirmation_height_exists (transaction_a, account_a)); nano::db_val info (info_a); auto status = put (transaction_a, tables::accounts, account_a, info); release_assert (success (status)); @@ -676,7 +676,7 @@ class block_store_partial : public block_store } } } - assert (result != nullptr); + debug_assert (result != nullptr); return result; } @@ -794,7 +794,7 @@ class block_store_partial : public block_store existing = make_iterator> (transaction_a, table_a); } auto end (nano::store_iterator> (nullptr)); - assert (existing != end); + debug_assert (existing != end); return block_get (transaction_a, nano::block_hash (existing->first)); } @@ -837,13 +837,13 @@ class block_store_partial : public block_store // Return account containing hash nano::account block_account_computed (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - assert (!full_sideband (transaction_a)); + debug_assert (!full_sideband (transaction_a)); nano::account result (0); auto hash (hash_a); while (result.is_zero ()) { auto block (block_get (transaction_a, hash)); - assert (block); + debug_assert (block); result = block->account (); if (result.is_zero ()) { @@ -866,20 +866,20 @@ class block_store_partial : public block_store if (result.is_zero ()) { auto successor (block_successor (transaction_a, hash)); - assert (!successor.is_zero ()); + debug_assert (!successor.is_zero ()); hash = successor; } } } } } - assert (!result.is_zero ()); + debug_assert (!result.is_zero ()); return result; } nano::uint128_t block_balance_computed (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - assert (!full_sideband (transaction_a)); + debug_assert (!full_sideband (transaction_a)); summation_visitor visitor (transaction_a, *this); return visitor.compute_balance (hash_a); } @@ -894,7 +894,7 @@ class block_store_partial : public block_store else { // Read old successor-only sideband - assert (entry_size_a == nano::block::size (type_a) + sizeof (nano::block_hash)); + debug_assert (entry_size_a == nano::block::size (type_a) + sizeof (nano::block_hash)); result = entry_size_a - sizeof (nano::block_hash); } return result; @@ -969,7 +969,7 @@ class block_store_partial : public block_store result = tables::state_blocks; break; default: - assert (false); + debug_assert (false); break; } return result; @@ -1025,7 +1025,7 @@ class block_predecessor_set : public nano::block_visitor auto hash (block_a.hash ()); nano::block_type type; auto value (store.block_raw_get (transaction, block_a.previous (), type)); - assert (value.size () != 0); + debug_assert (value.size () != 0); std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + store.block_successor_offset (transaction, value.size (), type)); store.block_raw_put (transaction, data, type, block_a.previous ()); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index b8d126be8d..4b732b4ec8 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -193,7 +193,7 @@ nano::keypair::keypair (std::string const & prv_a) { auto error (prv.data.decode_hex (prv_a)); (void)error; - assert (!error); + debug_assert (!error); ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ()); } @@ -248,13 +248,13 @@ bool nano::account_info::operator!= (nano::account_info const & other_a) const size_t nano::account_info::db_size () const { - assert (reinterpret_cast (this) == reinterpret_cast (&head)); - assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&representative)); - assert (reinterpret_cast (&representative) + sizeof (representative) == reinterpret_cast (&open_block)); - assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); - assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); - assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); - assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&epoch_m)); + debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); + debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&representative)); + debug_assert (reinterpret_cast (&representative) + sizeof (representative) == reinterpret_cast (&open_block)); + debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); + debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); + debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); + debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&epoch_m)); return sizeof (head) + sizeof (representative) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count) + sizeof (epoch_m); } @@ -345,7 +345,7 @@ confirmed (confirmed_a) void nano::unchecked_info::serialize (nano::stream & stream_a) const { - assert (block != nullptr); + debug_assert (block != nullptr); nano::serialize_block (stream_a, *block); nano::write (stream_a, account.bytes); nano::write (stream_a, modified); @@ -555,8 +555,8 @@ nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, sequence (sequence_a), account (account_a) { - assert (!blocks_a.empty ()); - assert (blocks_a.size () <= 12); + debug_assert (!blocks_a.empty ()); + debug_assert (blocks_a.size () <= 12); blocks.reserve (blocks_a.size ()); std::copy (blocks_a.cbegin (), blocks_a.cend (), std::back_inserter (blocks)); signature = nano::sign_message (prv_a, account_a, hash ()); @@ -620,7 +620,7 @@ void nano::vote::serialize (nano::stream & stream_a, nano::block_type type) cons { if (block.which ()) { - assert (type == nano::block_type::not_a_block); + debug_assert (type == nano::block_type::not_a_block); write (stream_a, boost::get (block)); } else @@ -806,7 +806,7 @@ nano::genesis::genesis () { static nano::network_params network_params; open = parse_block_from_genesis_data (network_params.ledger.genesis_block); - assert (open != nullptr); + debug_assert (open != nullptr); } nano::block_hash nano::genesis::hash () const diff --git a/nano/secure/epoch.cpp b/nano/secure/epoch.cpp index 29938d09a7..352dd1f42c 100644 --- a/nano/secure/epoch.cpp +++ b/nano/secure/epoch.cpp @@ -1,3 +1,4 @@ +#include #include nano::link const & nano::epochs::link (nano::epoch epoch_a) const @@ -18,13 +19,13 @@ nano::public_key const & nano::epochs::signer (nano::epoch epoch_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; })); - assert (existing != epochs_m.end ()); + debug_assert (existing != epochs_m.end ()); return existing->first; } void nano::epochs::add (nano::epoch epoch_a, nano::public_key const & signer_a, nano::link const & link_a) { - assert (epochs_m.find (epoch_a) == epochs_m.end ()); + debug_assert (epochs_m.find (epoch_a) == epochs_m.end ()); epochs_m[epoch_a] = { signer_a, link_a }; } @@ -40,6 +41,6 @@ std::underlying_type_t nano::normalized_epoch (nano::epoch epoch_a) // Currently assumes that the epoch versions in the enum are sequential. auto start = std::underlying_type_t (nano::epoch::epoch_0); auto end = std::underlying_type_t (epoch_a); - assert (end >= start); + debug_assert (end >= start); return end - start; } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 0fbdde3528..75e78dfcaf 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -34,7 +34,7 @@ class rollback_visitor : public nano::block_visitor nano::account_info info; auto error (ledger.store.account_get (transaction, pending.source, info)); (void)error; - assert (!error); + debug_assert (!error); ledger.store.pending_del (transaction, key); ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ()); nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0); @@ -55,7 +55,7 @@ class rollback_visitor : public nano::block_visitor nano::account_info info; auto error (ledger.store.account_get (transaction, destination_account, info)); (void)error; - assert (!error); + debug_assert (!error); ledger.cache.rep_weights.representation_add (info.representative, 0 - amount); nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0); ledger.change_latest (transaction, destination_account, info, new_info); @@ -88,7 +88,7 @@ class rollback_visitor : public nano::block_visitor nano::account_info info; auto error (ledger.store.account_get (transaction, account, info)); (void)error; - assert (!error); + debug_assert (!error); auto balance (ledger.balance (transaction, block_a.hashables.previous)); auto block = ledger.store.block_get (transaction, rep_block); release_assert (block != nullptr); @@ -120,7 +120,7 @@ class rollback_visitor : public nano::block_visitor { // Move existing representation auto block (ledger.store.block_get (transaction, rep_block_hash)); - assert (block != nullptr); + debug_assert (block != nullptr); representative = block->representative (); ledger.cache.rep_weights.representation_add (representative, balance); } @@ -146,7 +146,7 @@ class rollback_visitor : public nano::block_visitor ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } - assert (!error); + debug_assert (!error); auto previous_version (ledger.store.block_version (transaction, block_a.hashables.previous)); nano::account_info new_info (block_a.hashables.previous, representative, info.open_block, balance, nano::seconds_since_epoch (), info.block_count - 1, previous_version); ledger.change_latest (transaction, block_a.hashables.account, info, new_info); @@ -196,7 +196,7 @@ class ledger_processor : public nano::block_visitor // Returns true if this block which has an epoch link is correctly formed. bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) { - assert (ledger.is_epoch_link (block_a.hashables.link)); + debug_assert (ledger.is_epoch_link (block_a.hashables.link)); nano::amount prev_balance (0); if (!block_a.hashables.previous.is_zero ()) { @@ -267,7 +267,7 @@ void ledger_processor::state_block_impl (nano::state_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); + debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous) if (result.code == nano::process_result::progress) @@ -385,7 +385,7 @@ void ledger_processor::epoch_block_impl (nano::state_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature)); + debug_assert (!validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature)); result.verified = nano::signature_verification::valid_epoch; result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous) if (result.code == nano::process_result::progress) @@ -460,8 +460,8 @@ void ledger_processor::change_block (nano::change_block const & block_a) nano::account_info info; auto latest_error (ledger.store.account_get (transaction, account, info)); (void)latest_error; - assert (!latest_error); - assert (info.head == block_a.hashables.previous); + debug_assert (!latest_error); + debug_assert (info.head == block_a.hashables.previous); // Validate block if not verified outside of ledger if (result.verified != nano::signature_verification::valid) { @@ -469,7 +469,7 @@ void ledger_processor::change_block (nano::change_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (account, hash, block_a.signature)); + debug_assert (!validate_message (account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; nano::block_sideband sideband (nano::block_type::change, account, 0, info.balance, info.block_count + 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false); ledger.store.block_put (transaction, hash, block_a, sideband); @@ -515,13 +515,13 @@ void ledger_processor::send_block (nano::send_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (account, hash, block_a.signature)); + debug_assert (!validate_message (account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; nano::account_info info; auto latest_error (ledger.store.account_get (transaction, account, info)); (void)latest_error; - assert (!latest_error); - assert (info.head == block_a.hashables.previous); + debug_assert (!latest_error); + debug_assert (info.head == block_a.hashables.previous); result.code = info.balance.number () >= block_a.hashables.balance.number () ? nano::process_result::progress : nano::process_result::negative_spend; // Is this trying to spend a negative amount (Malicious) if (result.code == nano::process_result::progress) { @@ -571,7 +571,7 @@ void ledger_processor::receive_block (nano::receive_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (account, hash, block_a.signature)); + debug_assert (!validate_message (account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; result.code = ledger.store.source_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless) if (result.code == nano::process_result::progress) @@ -593,7 +593,7 @@ void ledger_processor::receive_block (nano::receive_block const & block_a) nano::account_info source_info; auto error (ledger.store.account_get (transaction, pending.source, source_info)); (void)error; - assert (!error); + debug_assert (!error); ledger.store.pending_del (transaction, key); nano::block_sideband sideband (nano::block_type::receive, account, 0, new_balance, info.block_count + 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); ledger.store.block_put (transaction, hash, block_a, sideband); @@ -634,7 +634,7 @@ void ledger_processor::open_block (nano::open_block const & block_a) } if (result.code == nano::process_result::progress) { - assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); + debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; result.code = ledger.store.source_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block? (Harmless) if (result.code == nano::process_result::progress) @@ -657,7 +657,7 @@ void ledger_processor::open_block (nano::open_block const & block_a) nano::account_info source_info; auto error (ledger.store.account_get (transaction, pending.source, source_info)); (void)error; - assert (!error); + debug_assert (!error); ledger.store.pending_del (transaction, key); nano::block_sideband sideband (nano::block_type::open, block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); ledger.store.block_put (transaction, hash, block_a, sideband); @@ -754,7 +754,7 @@ nano::uint128_t nano::ledger::account_pending (nano::transaction const & transac nano::process_return nano::ledger::process (nano::write_transaction const & transaction_a, nano::block const & block_a, nano::signature_verification verification) { - assert (!nano::work_validate (nano::work_version::work_1, block_a)); + debug_assert (!nano::work_validate (nano::work_version::work_1, block_a)); ledger_processor processor (*this, transaction_a, verification); block_a.visit (processor); if (processor.result.code == nano::process_result::progress) @@ -767,7 +767,7 @@ nano::process_return nano::ledger::process (nano::write_transaction const & tran nano::block_hash nano::ledger::representative (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { auto result (representative_calculated (transaction_a, hash_a)); - assert (result.is_zero () || store.block_exists (transaction_a, result)); + debug_assert (result.is_zero () || store.block_exists (transaction_a, result)); return result; } @@ -846,7 +846,7 @@ nano::block_hash nano::ledger::block_source (nano::transaction const & transacti * passed in exist in the database. This is because it will try * to check account balances to determine if it is a send block. */ - assert (block_a.previous ().is_zero () || store.block_exists (transaction_a, block_a.previous ())); + debug_assert (block_a.previous ().is_zero () || store.block_exists (transaction_a, block_a.previous ())); // If block_a.source () is nonzero, then we have our source. // However, universal blocks will always return zero. @@ -883,7 +883,7 @@ nano::uint128_t nano::ledger::weight (nano::account const & account_a) // Rollback blocks until `block_a' doesn't exist or it tries to penetrate the confirmation height bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano::block_hash const & block_a, std::vector> & list_a) { - assert (store.block_exists (transaction_a, block_a)); + debug_assert (store.block_exists (transaction_a, block_a)); auto account_l (account (transaction_a, block_a)); auto block_account_height (store.block_account_height (transaction_a, block_a)); rollback_visitor rollback (transaction_a, *this, list_a); @@ -893,12 +893,12 @@ bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano { nano::confirmation_height_info confirmation_height_info; auto latest_error = store.confirmation_height_get (transaction_a, account_l, confirmation_height_info); - assert (!latest_error); + debug_assert (!latest_error); (void)latest_error; if (block_account_height > confirmation_height_info.height) { latest_error = store.account_get (transaction_a, account_l, account_info); - assert (!latest_error); + debug_assert (!latest_error); auto block (store.block_get (transaction_a, account_info.head)); list_a.push_back (block); block->visit (rollback); @@ -972,7 +972,7 @@ void nano::ledger::dump_account_chain (nano::account const & account_a) while (!hash.is_zero ()) { auto block (store.block_get (transaction, hash)); - assert (block != nullptr); + debug_assert (block != nullptr); std::cerr << hash.to_string () << std::endl; hash = block->previous (); } @@ -1045,7 +1045,7 @@ void nano::ledger::change_latest (nano::write_transaction const & transaction_a, { if (old_a.head.is_zero () && new_a.open_block == new_a.head) { - assert (!store.confirmation_height_exists (transaction_a, account_a)); + debug_assert (!store.confirmation_height_exists (transaction_a, account_a)); store.confirmation_height_put (transaction_a, account_a, { 0, nano::block_hash (0) }); ++cache.account_count; } @@ -1060,7 +1060,7 @@ void nano::ledger::change_latest (nano::write_transaction const & transaction_a, { store.confirmation_height_del (transaction_a, account_a); store.account_del (transaction_a, account_a); - assert (cache.account_count > 0); + debug_assert (cache.account_count > 0); --cache.account_count; } } @@ -1095,24 +1095,24 @@ std::shared_ptr nano::ledger::successor (nano::transaction const & { result = store.block_get (transaction_a, successor); } - assert (successor.is_zero () || result != nullptr); + debug_assert (successor.is_zero () || result != nullptr); return result; } std::shared_ptr nano::ledger::forked_block (nano::transaction const & transaction_a, nano::block const & block_a) { - assert (!store.block_exists (transaction_a, block_a.type (), block_a.hash ())); + debug_assert (!store.block_exists (transaction_a, block_a.type (), block_a.hash ())); auto root (block_a.root ()); - assert (store.block_exists (transaction_a, root) || store.account_exists (transaction_a, root)); + debug_assert (store.block_exists (transaction_a, root) || store.account_exists (transaction_a, root)); auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root))); if (result == nullptr) { nano::account_info info; auto error (store.account_get (transaction_a, root, info)); (void)error; - assert (!error); + debug_assert (!error); result = store.block_get (transaction_a, info.open_block); - assert (result != nullptr); + debug_assert (result != nullptr); } return result; } diff --git a/nano/secure/network_filter.cpp b/nano/secure/network_filter.cpp index 572d2e57d1..b6fc7b3f2b 100644 --- a/nano/secure/network_filter.cpp +++ b/nano/secure/network_filter.cpp @@ -64,8 +64,8 @@ void nano::network_filter::clear () nano::uint128_t & nano::network_filter::get_element (nano::uint128_t const & hash_a) { - assert (!mutex.try_lock ()); - assert (items.size () > 0); + debug_assert (!mutex.try_lock ()); + debug_assert (items.size () > 0); size_t index (hash_a % items.size ()); return items[index]; } diff --git a/nano/secure/plat/posix/working.cpp b/nano/secure/plat/posix/working.cpp index 9b56aca5dd..1d36b163ba 100644 --- a/nano/secure/plat/posix/working.cpp +++ b/nano/secure/plat/posix/working.cpp @@ -1,3 +1,4 @@ +#include #include #include @@ -8,7 +9,7 @@ namespace nano boost::filesystem::path app_path () { auto entry (getpwuid (getuid ())); - assert (entry != nullptr); + debug_assert (entry != nullptr); boost::filesystem::path result (entry->pw_dir); return result; } diff --git a/nano/secure/plat/windows/working.cpp b/nano/secure/plat/windows/working.cpp index 958103e85d..91cf371999 100644 --- a/nano/secure/plat/windows/working.cpp +++ b/nano/secure/plat/windows/working.cpp @@ -16,7 +16,7 @@ boost::filesystem::path app_path () } else { - assert (false); + debug_assert (false); } return result; } diff --git a/nano/secure/versioning.cpp b/nano/secure/versioning.cpp index 0ed201d8ed..62f3f5041c 100644 --- a/nano/secure/versioning.cpp +++ b/nano/secure/versioning.cpp @@ -6,7 +6,7 @@ nano::account_info_v1::account_info_v1 (MDB_val const & val_a) { - assert (val_a.mv_size == sizeof (*this)); + debug_assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (head) + sizeof (rep_block) + sizeof (balance) + sizeof (modified) == sizeof (*this), "Class not packed"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } @@ -21,7 +21,7 @@ modified (modified_a) nano::pending_info_v3::pending_info_v3 (MDB_val const & val_a) { - assert (val_a.mv_size == sizeof (*this)); + debug_assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (source) + sizeof (amount) + sizeof (destination) == sizeof (*this), "Packed class"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } @@ -68,7 +68,7 @@ bool nano::pending_info_v14::operator== (nano::pending_info_v14 const & other_a) nano::account_info_v5::account_info_v5 (MDB_val const & val_a) { - assert (val_a.mv_size == sizeof (*this)); + debug_assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) == sizeof (*this), "Class not packed"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } @@ -95,12 +95,12 @@ epoch (epoch_a) size_t nano::account_info_v13::db_size () const { - assert (reinterpret_cast (this) == reinterpret_cast (&head)); - assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); - assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); - assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); - assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); - assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); + debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); + debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); + debug_assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); + debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); + debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); + debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); return sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count); } @@ -118,13 +118,13 @@ epoch (epoch_a) size_t nano::account_info_v14::db_size () const { - assert (reinterpret_cast (this) == reinterpret_cast (&head)); - assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); - assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); - assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); - assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); - assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); - assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&confirmation_height)); + debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); + debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); + debug_assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); + debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); + debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); + debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); + debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&confirmation_height)); return sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count) + sizeof (confirmation_height); } diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 30733e0d5a..1f0202b9bf 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -309,7 +309,7 @@ TEST (broadcast, world_broadcast_simulate) case 2: break; default: - assert (false); + ASSERT_FALSE (true); break; } } @@ -362,7 +362,7 @@ TEST (broadcast, sqrt_broadcast_simulate) case 2: break; default: - assert (false); + ASSERT_FALSE (true); break; } } @@ -660,7 +660,6 @@ TEST (confirmation_height, long_chains) auto transaction (node->store.tx_begin_read ()); nano::account_info account_info; ASSERT_FALSE (node->store.account_get (transaction, nano::test_genesis_key.pub, account_info)); - uint64_t confirmation_height; nano::confirmation_height_info confirmation_height_info; ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::test_genesis_key.pub, confirmation_height_info)); ASSERT_EQ (num_blocks + 2, confirmation_height_info.height); @@ -847,7 +846,7 @@ class data std::atomic awaiting_cache{ false }; std::atomic keep_requesting_metrics{ true }; std::shared_ptr node; - std::chrono::steady_clock::time_point orig_time; + std::chrono::system_clock::time_point orig_time; std::atomic_flag orig_time_set = ATOMIC_FLAG_INIT; }; class shared_data @@ -860,7 +859,7 @@ class shared_data }; template -void callback_process (shared_data & shared_data_a, data & data, T & all_node_data_a, std::chrono::steady_clock::time_point last_updated) +void callback_process (shared_data & shared_data_a, data & data, T & all_node_data_a, std::chrono::system_clock::time_point last_updated) { if (!data.orig_time_set.test_and_set ()) { @@ -922,7 +921,7 @@ TEST (node_telemetry, ongoing_requests) } } -TEST (node_telemetry, simultaneous_random_requests) +TEST (node_telemetry, simultaneous_all_requests) { const auto num_nodes = 4; nano::system system (num_nodes); @@ -955,7 +954,7 @@ TEST (node_telemetry, simultaneous_random_requests) { ++shared_data.count; data.node->telemetry.get_metrics_peers_async ([&shared_data, &data, &all_data](nano::telemetry_data_responses const & responses_a) { - callback_process (shared_data, data, all_data, responses_a.telemetry_data_time_pairs.begin ()->second.last_updated); + callback_process (shared_data, data, all_data, *responses_a.telemetry_datas.begin ()->second.timestamp); }); } std::this_thread::sleep_for (1ms); @@ -983,7 +982,7 @@ namespace nano { namespace transport { - TEST (node_telemetry, simultaneous_single_and_random_requests) + TEST (node_telemetry, simultaneous_single_and_all_requests) { const auto num_nodes = 4; nano::system system (num_nodes); @@ -994,21 +993,21 @@ namespace transport const auto num_threads = 4; std::array node_data_single{}; - std::array node_data_random{}; + std::array node_data_all{}; for (auto i = 0; i < num_nodes; ++i) { node_data_single[i].node = system.nodes[i]; - node_data_random[i].node = system.nodes[i]; + node_data_all[i].node = system.nodes[i]; } shared_data shared_data_single; - shared_data shared_data_random; + shared_data shared_data_all; // Create a few threads where each node sends out telemetry request messages to all other nodes continuously, until the cache it reached and subsequently expired. // The test waits until all telemetry_ack messages have been received. for (int i = 0; i < num_threads; ++i) { - threads.emplace_back ([&node_data_single, &node_data_random, &shared_data_single, &shared_data_random]() { + threads.emplace_back ([&node_data_single, &node_data_all, &shared_data_single, &shared_data_all]() { auto func = [](auto & all_node_data_a, shared_data & shared_data_a, bool single_a) { while (std::any_of (all_node_data_a.cbegin (), all_node_data_a.cend (), [](auto const & data) { return data.keep_requesting_metrics.load (); })) { @@ -1024,13 +1023,13 @@ namespace transport // Pick first peer to be consistent auto peer = data.node->network.tcp_channels.channels[0].channel; data.node->telemetry.get_metrics_single_peer_async (peer, [&shared_data_a, &data, &all_node_data_a](nano::telemetry_data_response const & telemetry_data_response_a) { - callback_process (shared_data_a, data, all_node_data_a, telemetry_data_response_a.telemetry_data_time_pair.last_updated); + callback_process (shared_data_a, data, all_node_data_a, *telemetry_data_response_a.telemetry_data.timestamp); }); } else { data.node->telemetry.get_metrics_peers_async ([&shared_data_a, &data, &all_node_data_a](nano::telemetry_data_responses const & telemetry_data_responses_a) { - callback_process (shared_data_a, data, all_node_data_a, telemetry_data_responses_a.telemetry_data_time_pairs.begin ()->second.last_updated); + callback_process (shared_data_a, data, all_node_data_a, *telemetry_data_responses_a.telemetry_datas.begin ()->second.timestamp); }); } } @@ -1043,12 +1042,12 @@ namespace transport }; func (node_data_single, shared_data_single, true); - func (node_data_random, shared_data_random, false); + func (node_data_all, shared_data_all, false); }); } system.deadline_set (30s); - while (!shared_data_random.done || !shared_data_single.done) + while (!shared_data_all.done || !shared_data_single.done) { ASSERT_NO_ERROR (system.poll ()); }