From b0896aa755d8fcbb6c0cef25b31bed8157829c8f Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 17 Jan 2024 20:10:06 +0000 Subject: [PATCH 001/190] Store pointer to boost::asio::signal_set and cancel when ipc_server::stop is called. Previously the signals weren't cancelled on ipc_server and would remain running until the io_context was destroyed. --- nano/node/ipc/ipc_server.cpp | 7 +++++-- nano/node/ipc/ipc_server.hpp | 3 +++ 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index 9eaf1e7509..777a9ee2bb 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -14,7 +14,6 @@ #include #include -#include #include #include @@ -614,7 +613,7 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co } #ifndef _WIN32 // Hook up config reloading through the HUP signal - auto signals (std::make_shared (node.io_ctx, SIGHUP)); + signals = std::make_shared (node.io_ctx, SIGHUP); await_hup_signal (signals, *this); #endif if (node_a.config.ipc_config.transport_domain.enabled) @@ -659,6 +658,10 @@ void nano::ipc::ipc_server::stop () { transport->stop (); } + if (signals) + { + signals->cancel (); + } } std::optional nano::ipc::ipc_server::listening_tcp_port () const diff --git a/nano/node/ipc/ipc_server.hpp b/nano/node/ipc/ipc_server.hpp index a9f175dbbc..378d78eb32 100644 --- a/nano/node/ipc/ipc_server.hpp +++ b/nano/node/ipc/ipc_server.hpp @@ -6,6 +6,8 @@ #include #include +#include + #include #include @@ -41,6 +43,7 @@ namespace ipc nano::ipc::access access; std::unique_ptr file_remover; std::vector> transports; + std::shared_ptr signals; }; } } From 3b79c84307d2b4fd44533c21435ec6efb098ba32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 9 Jan 2024 19:34:03 +0100 Subject: [PATCH 002/190] Add `fmt` & `spdlog` submodules --- .gitmodules | 6 ++++++ CMakeLists.txt | 10 ++++++++++ nano/lib/CMakeLists.txt | 2 ++ submodules/fmt | 1 + submodules/spdlog | 1 + 5 files changed, 20 insertions(+) create mode 160000 submodules/fmt create mode 160000 submodules/spdlog diff --git a/.gitmodules b/.gitmodules index 6f9e8c84da..c1d9a0bf26 100644 --- a/.gitmodules +++ b/.gitmodules @@ -31,3 +31,9 @@ [submodule "submodules/gtest-parallel"] path = submodules/gtest-parallel url = https://github.com/google/gtest-parallel.git +[submodule "submodules/spdlog"] + path = submodules/spdlog + url = https://github.com/gabime/spdlog.git +[submodule "submodules/fmt"] + path = submodules/fmt + url = https://github.com/fmtlib/fmt.git diff --git a/CMakeLists.txt b/CMakeLists.txt index c48e2df2a4..a4c52fc9bc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -536,6 +536,16 @@ add_subdirectory(crypto/ed25519-donna) add_subdirectory(nano/ipc_flatbuffers_lib) add_subdirectory(nano/ipc_flatbuffers_test) +# fmt +add_subdirectory(submodules/fmt EXCLUDE_FROM_ALL) +include_directories(submodules/fmt/include) + +# spdlog +add_definitions(-DSPDLOG_FMT_EXTERNAL) +add_subdirectory(submodules/spdlog EXCLUDE_FROM_ALL) +include_directories(submodules/spdlog/include) + +# miniupnp set(UPNPC_BUILD_SHARED OFF CACHE BOOL "") diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index d56f55e8f7..a15ef4c7fd 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -111,6 +111,8 @@ target_link_libraries( blake2 ${CRYPTOPP_LIBRARY} ${CMAKE_DL_LIBS} + fmt::fmt + spdlog::spdlog Boost::iostreams Boost::asio Boost::circular_buffer diff --git a/submodules/fmt b/submodules/fmt new file mode 160000 index 0000000000..a0b8a92e3d --- /dev/null +++ b/submodules/fmt @@ -0,0 +1 @@ +Subproject commit a0b8a92e3d1532361c2f7feb63babc5c18d00ef2 diff --git a/submodules/spdlog b/submodules/spdlog new file mode 160000 index 0000000000..7e635fca68 --- /dev/null +++ b/submodules/spdlog @@ -0,0 +1 @@ +Subproject commit 7e635fca68d014934b4af8a1cf874f63989352b7 From b7702970455c4fa5bb4c03d0d70ca650a7a7e916 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 16 Jan 2024 17:07:22 +0100 Subject: [PATCH 003/190] Add helper functions for configuration file loading --- nano/lib/config.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ nano/lib/config.hpp | 22 ++++++++++++++++++++++ 2 files changed, 66 insertions(+) diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index 13273e1096..506a2cb3e1 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -355,3 +355,47 @@ uint32_t nano::test_scan_wallet_reps_delay () auto test_env = nano::get_env_or_default ("NANO_TEST_WALLET_SCAN_REPS_DELAY", "900000"); // 15 minutes by default return boost::lexical_cast (test_env); } + +nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides) +{ + std::stringstream config_overrides_stream; + for (auto const & entry : config_overrides) + { + config_overrides_stream << entry << std::endl; + } + config_overrides_stream << std::endl; + + auto try_load_toml = [&config_overrides_stream] (auto toml_config_path) -> std::optional { + // Make sure we don't create an empty toml file if it doesn't exist. Running without a toml file is the default. + if (std::filesystem::exists (toml_config_path)) + { + nano::tomlconfig toml; + auto error = toml.read (config_overrides_stream, toml_config_path); + if (error) + { + throw std::runtime_error (error.get_message ()); + } + return toml; + } + return std::nullopt; + }; + + // First try to load config from the current working directory, then from the node data directory + if (auto toml = try_load_toml (config_filename); toml) + { + return *toml; + } + if (auto toml = try_load_toml (data_path / config_filename); toml) + { + return *toml; + } + + // If no config was found, return an empty config with overrides applied + nano::tomlconfig toml; + auto error = toml.read (config_overrides_stream); + if (error) + { + throw std::runtime_error (error.get_message ()); + } + return toml; +} diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index db8ef89752..f1e94c2383 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -1,5 +1,7 @@ #pragma once +#include + #include #include @@ -404,4 +406,24 @@ bool is_sanitizer_build (); /** Set the active network to the dev network */ void force_nano_dev_network (); + +/** + * Attempt to read a configuration file from current working directory, or if not found, the nano root directory. + * Returns empty tomlconfig if nothing is found. + */ +nano::tomlconfig load_toml_file (const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides); + +template +T load_config_file (T fallback, const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides) +{ + auto toml = load_toml_file (config_filename, data_path, config_overrides); + + T config = fallback; + auto error = config.deserialize_toml (toml); + if (error) + { + throw std::runtime_error (error.get_message ()); + } + return config; +} } From 8f42544e99e67bc492dbc574852cee2f3d065e67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 9 Jan 2024 22:14:36 +0100 Subject: [PATCH 004/190] Fix cpptoml --- CMakeLists.txt | 4 ++-- nano/core_test/CMakeLists.txt | 1 - nano/lib/CMakeLists.txt | 1 - nano/load_test/CMakeLists.txt | 1 - nano/node/CMakeLists.txt | 1 - 5 files changed, 2 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a4c52fc9bc..925be3b5a2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -526,7 +526,8 @@ else() endif() add_subdirectory(submodules/rocksdb EXCLUDE_FROM_ALL) -include_directories(cpptoml/include) +# cpptoml +include_directories(submodules/cpptoml/include) # magic_enum include_directories(submodules/magic_enum/include) @@ -770,7 +771,6 @@ if(NANO_GUI OR RAIBLOCKS_GUI) add_library(qt nano/qt/qt.cpp nano/qt/qt.hpp) include_directories(${CMAKE_SOURCE_DIR}/submodules) - include_directories(${CMAKE_SOURCE_DIR}/submodules/cpptoml/include) target_link_libraries( qt diff --git a/nano/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt index 059d15acd1..623e6f2601 100644 --- a/nano/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -64,5 +64,4 @@ target_compile_definitions( target_link_libraries(core_test test_common) include_directories(${CMAKE_SOURCE_DIR}/submodules) -include_directories(${CMAKE_SOURCE_DIR}/submodules/cpptoml/include) include_directories(${CMAKE_SOURCE_DIR}/submodules/gtest/googletest/include) diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index a15ef4c7fd..eb0e8097bb 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -100,7 +100,6 @@ add_library( work.cpp) include_directories(${CMAKE_SOURCE_DIR}/submodules) -include_directories(${CMAKE_SOURCE_DIR}/submodules/cpptoml/include) include_directories( ${CMAKE_SOURCE_DIR}/submodules/nano-pow-server/deps/cpptoml/include) diff --git a/nano/load_test/CMakeLists.txt b/nano/load_test/CMakeLists.txt index 71a99cc371..0864ac6cfe 100644 --- a/nano/load_test/CMakeLists.txt +++ b/nano/load_test/CMakeLists.txt @@ -3,5 +3,4 @@ add_executable(load_test entry.cpp) target_link_libraries(load_test test_common Boost::process) include_directories(${CMAKE_SOURCE_DIR}/submodules) -include_directories(${CMAKE_SOURCE_DIR}/submodules/cpptoml/include) include_directories(${CMAKE_SOURCE_DIR}/submodules/gtest/googletest/include) diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index b4de400f8f..52d7eec664 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -223,6 +223,5 @@ target_compile_definitions( add_dependencies(node ipc_flatbuffers_lib) include_directories(${CMAKE_SOURCE_DIR}/submodules) -include_directories(${CMAKE_SOURCE_DIR}/submodules/cpptoml/include) include_directories( ${CMAKE_SOURCE_DIR}/submodules/nano-pow-server/deps/cpptoml/include) From 3be57598fd9489122753332e7bd4fe58451fe1ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 16 Jan 2024 19:16:47 +0100 Subject: [PATCH 005/190] Add `tomlconfig::get_values ()` --- nano/lib/tomlconfig.hpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/nano/lib/tomlconfig.hpp b/nano/lib/tomlconfig.hpp index e04af3bc05..140e1b0ab9 100644 --- a/nano/lib/tomlconfig.hpp +++ b/nano/lib/tomlconfig.hpp @@ -171,6 +171,19 @@ class tomlconfig : public nano::configbase return *this; } + template + std::vector> get_values () + { + std::vector> result; + for (auto & entry : *tree) + { + T target{}; + get_config (true, entry.first, target, target); + result.push_back ({ entry.first, target }); + } + return result; + } + protected: template ::value>> tomlconfig & get_config (bool optional, std::string const & key, T & target, T default_value = T ()) From 6911a2dbb42e4c831a999033eb5f139691958985 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 9 Jan 2024 19:37:22 +0100 Subject: [PATCH 006/190] Introduce new `logger` --- nano/lib/CMakeLists.txt | 4 + nano/lib/logging.cpp | 350 +++++++++++++++++++++++++++++++++++++ nano/lib/logging.hpp | 134 ++++++++++++++ nano/lib/logging_enums.cpp | 91 ++++++++++ nano/lib/logging_enums.hpp | 140 +++++++++++++++ 5 files changed, 719 insertions(+) create mode 100644 nano/lib/logging.cpp create mode 100644 nano/lib/logging.hpp create mode 100644 nano/lib/logging_enums.cpp create mode 100644 nano/lib/logging_enums.hpp diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index eb0e8097bb..102cb2e931 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -51,6 +51,10 @@ add_library( locks.hpp locks.cpp logger_mt.hpp + logging.hpp + logging.cpp + logging_enums.hpp + logging_enums.cpp memory.hpp memory.cpp numbers.hpp diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp new file mode 100644 index 0000000000..aafc146624 --- /dev/null +++ b/nano/lib/logging.cpp @@ -0,0 +1,350 @@ +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace +{ +std::atomic logging_initialized{ false }; +} + +nano::nlogger & nano::default_logger () +{ + static nano::nlogger logger{ "default" }; + return logger; +} + +/* + * nlogger + */ + +bool nano::nlogger::global_initialized; +nano::log_config nano::nlogger::global_config; +std::vector nano::nlogger::global_sinks; + +void nano::nlogger::initialize (nano::log_config config) +{ + spdlog::set_automatic_registration (false); + spdlog::set_level (to_spdlog_level (config.default_level)); + spdlog::cfg::load_env_levels (); + + global_sinks.clear (); + + // Console setup + if (config.console.enable) + { + if (!config.console.to_cerr) + { + // Only use colors if not writing to cerr + if (config.console.colors) + { + auto console_sink = std::make_shared (); + global_sinks.push_back (console_sink); + } + else + { + auto console_sink = std::make_shared (); + global_sinks.push_back (console_sink); + } + } + else + { + auto cerr_sink = std::make_shared (); + global_sinks.push_back (cerr_sink); + } + } + + // File setup + if (config.file.enable) + { + auto now = std::chrono::system_clock::now (); + auto time = std::chrono::system_clock::to_time_t (now); + + auto filename = fmt::format ("log_{:%Y-%m-%d_%H-%M}-{:%S}", fmt::localtime (time), now.time_since_epoch ()); + std::replace (filename.begin (), filename.end (), '.', '_'); // Replace millisecond dot separator with underscore + + std::filesystem::path log_path{ "log" }; + log_path /= filename + ".log"; + + nano::default_logger ().info (nano::log::type::logging, "Logging to file: {}", log_path.string ()); + + // If either max_size or rotation_count is 0, then disable file rotation + if (config.file.max_size == 0 || config.file.rotation_count == 0) + { + // TODO: Maybe show a warning to the user about possibly unlimited log file size + + auto file_sink = std::make_shared (log_path, true); + global_sinks.push_back (file_sink); + } + else + { + auto file_sink = std::make_shared (log_path, config.file.max_size, config.file.rotation_count); + global_sinks.push_back (file_sink); + } + } + + auto logger = std::make_shared ("default", global_sinks.begin (), global_sinks.end ()); + spdlog::set_default_logger (logger); + + global_initialized = true; +} + +void nano::nlogger::flush () +{ + for (auto & sink : global_sinks) + { + sink->flush (); + } +} + +/* + * nlogger + */ + +nano::nlogger::nlogger (std::string identifier) : + identifier{ std::move (identifier) } +{ +} + +spdlog::logger & nano::nlogger::get_logger (nano::log::type tag) +{ + // This is a two-step process to avoid exclusively locking the mutex in the common case + { + std::shared_lock slock{ mutex }; + + if (auto it = spd_loggers.find (tag); it != spd_loggers.end ()) + { + return *it->second; + } + } + // Not found, create a new logger + { + std::unique_lock lock{ mutex }; + + auto [it2, inserted] = spd_loggers.emplace (tag, make_logger (tag)); + return *it2->second; + } +} + +std::shared_ptr nano::nlogger::make_logger (nano::log::type tag) +{ + auto spd_logger = std::make_shared (std::string{ to_string (tag) }, global_sinks.begin (), global_sinks.end ()); + + spdlog::initialize_logger (spd_logger); + + if (auto it = global_config.levels.find ({ tag, nano::log::detail::all }); it != global_config.levels.end ()) + { + spd_logger->set_level (to_spdlog_level (it->second)); + } + else + { + spd_logger->set_level (to_spdlog_level (global_config.default_level)); + } + + return spd_logger; +} + +spdlog::level::level_enum nano::to_spdlog_level (nano::log::level level) +{ + switch (level) + { + case nano::log::level::off: + return spdlog::level::off; + case nano::log::level::critical: + return spdlog::level::critical; + case nano::log::level::error: + return spdlog::level::err; + case nano::log::level::warn: + return spdlog::level::warn; + case nano::log::level::info: + return spdlog::level::info; + case nano::log::level::debug: + return spdlog::level::debug; + case nano::log::level::trace: + return spdlog::level::trace; + } + debug_assert (false, "Invalid log level"); + return spdlog::level::off; +} + +/* + * logging config presets + */ + +nano::log_config nano::log_config::cli_default () +{ + log_config config; + config.default_level = nano::log::level::critical; + return config; +} + +nano::log_config nano::log_config::daemon_default () +{ + log_config config; + config.default_level = nano::log::level::info; + return config; +} + +nano::log_config nano::log_config::tests_default () +{ + log_config config; + config.default_level = nano::log::level::critical; + return config; +} + +/* + * logging config + */ + +nano::error nano::log_config::serialize_toml (nano::tomlconfig & toml) const +{ + nano::tomlconfig config_toml; + serialize (config_toml); + toml.put_child ("log", config_toml); + + return toml.get_error (); +} + +nano::error nano::log_config::deserialize_toml (nano::tomlconfig & toml) +{ + try + { + auto logging_l = toml.get_optional_child ("log"); + if (logging_l) + { + deserialize (*logging_l); + } + } + catch (std::invalid_argument const & ex) + { + toml.get_error ().set (ex.what ()); + } + + return toml.get_error (); +} + +void nano::log_config::serialize (nano::tomlconfig & toml) const +{ + toml.put ("default_level", std::string{ to_string (default_level) }); + + nano::tomlconfig console_config; + console_config.put ("enable", console.enable); + console_config.put ("to_cerr", console.to_cerr); + console_config.put ("colors", console.colors); + toml.put_child ("console", console_config); + + nano::tomlconfig file_config; + file_config.put ("enable", file.enable); + file_config.put ("max_size", file.max_size); + file_config.put ("rotation_count", file.rotation_count); + toml.put_child ("file", file_config); + + nano::tomlconfig levels_config; + for (auto const & [logger_id, level] : levels) + { + auto logger_name = to_string (logger_id.first); + levels_config.put (std::string{ logger_name }, std::string{ to_string (level) }); + } + toml.put_child ("levels", levels_config); +} + +void nano::log_config::deserialize (nano::tomlconfig & toml) +{ + if (toml.has_key ("default_level")) + { + auto default_level_l = toml.get ("default_level"); + default_level = nano::log::to_level (default_level_l); + } + + if (toml.has_key ("console")) + { + auto console_config = toml.get_required_child ("console"); + console.enable = console_config.get ("enable"); + console.to_cerr = console_config.get ("to_cerr"); + console.colors = console_config.get ("colors"); + } + + if (toml.has_key ("file")) + { + auto file_config = toml.get_required_child ("file"); + file.enable = file_config.get ("enable"); + file.max_size = file_config.get ("max_size"); + file.rotation_count = file_config.get ("rotation_count"); + } + + if (toml.has_key ("levels")) + { + auto levels_config = toml.get_required_child ("levels"); + for (auto & level : levels_config.get_values ()) + { + try + { + auto & [name_str, level_str] = level; + auto logger_level = nano::log::to_level (level_str); + auto logger_id = parse_logger_id (name_str); + + levels[logger_id] = logger_level; + } + catch (std::invalid_argument const & ex) + { + // Ignore but warn about invalid logger names + std::cerr << "Problem processing log config: " << ex.what () << std::endl; + } + } + } +} + +/** + * Parse `logger_name[:logger_detail]` into a pair of `log::type` and `log::detail` + * @throw std::invalid_argument if `logger_name` or `logger_detail` are invalid + */ +nano::log_config::logger_id_t nano::log_config::parse_logger_id (const std::string & logger_name) +{ + auto pos = logger_name.find ("::"); + if (pos == std::string::npos) + { + return { nano::log::to_type (logger_name), nano::log::detail::all }; + } + else + { + auto logger_type = logger_name.substr (0, pos); + auto logger_detail = logger_name.substr (pos + 1); + + return { nano::log::to_type (logger_type), nano::log::to_detail (logger_detail) }; + } +} + +std::map nano::log_config::default_levels (nano::log::level default_level) +{ + std::map result; + for (auto const & type : nano::log::all_types ()) + { + result.emplace (std::make_pair (type, nano::log::detail::all), default_level); + } + return result; +} + +/* + * config loading + */ + +nano::log_config nano::load_log_config (nano::log_config fallback, const std::filesystem::path & data_path, const std::vector & config_overrides) +{ + const std::string config_filename = "config-log.toml"; + try + { + auto config = nano::load_config_file (fallback, config_filename, data_path, config_overrides); + return config; + } + catch (std::runtime_error const & ex) + { + std::cerr << "Unable to load log config. Using defaults. Error: " << ex.what () << std::endl; + } + return fallback; +} \ No newline at end of file diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp new file mode 100644 index 0000000000..26df820ff6 --- /dev/null +++ b/nano/lib/logging.hpp @@ -0,0 +1,134 @@ +#pragma once + +#include +#include + +#include +#include +#include +#include + +#include + +namespace nano +{ +class log_config final +{ +public: + nano::error serialize_toml (nano::tomlconfig &) const; + nano::error deserialize_toml (nano::tomlconfig &); + +private: + void serialize (nano::tomlconfig &) const; + void deserialize (nano::tomlconfig &); + +public: + nano::log::level default_level{ nano::log::level::info }; + + using logger_id_t = std::pair; + std::map levels{ default_levels (default_level) }; + + struct console_config + { + bool enable{ true }; + bool colors{ true }; + bool to_cerr{ false }; + }; + + struct file_config + { + bool enable{ true }; + std::size_t max_size{ 32 * 1024 * 1024 }; + std::size_t rotation_count{ 4 }; + }; + + console_config console; + file_config file; + +public: // Predefined defaults + static log_config cli_default (); + static log_config daemon_default (); + static log_config tests_default (); + +private: + logger_id_t parse_logger_id (std::string const &); + + /// Returns placeholder log levels for all loggers + static std::map default_levels (nano::log::level); +}; + +/// @throws std::runtime_error if the log config file is malformed +nano::log_config load_log_config (nano::log_config fallback, std::filesystem::path const & data_path = {}, std::vector const & config_overrides = std::vector ()); +} + +namespace nano +{ +spdlog::level::level_enum to_spdlog_level (nano::log::level); + +class nlogger final +{ +public: + nlogger (std::string identifier = ""); + + // Disallow copies + nlogger (nlogger const &) = delete; + +public: + static void initialize (nano::log_config); + static void flush (); + +private: + static bool global_initialized; + static nano::log_config global_config; + static std::vector global_sinks; + +public: + template + void log (nano::log::level level, nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).log (to_spdlog_level (level), fmt, std::forward (args)...); + } + + template + void debug (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).debug (fmt, std::forward (args)...); + } + + template + void info (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).info (fmt, std::forward (args)...); + } + + template + void warn (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).warn (fmt, std::forward (args)...); + } + + template + void error (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).error (fmt, std::forward (args)...); + } + + template + void critical (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + { + get_logger (tag).critical (fmt, std::forward (args)...); + } + +private: + const std::string identifier; + + std::unordered_map> spd_loggers; + std::shared_mutex mutex; + +private: + spdlog::logger & get_logger (nano::log::type tag); + std::shared_ptr make_logger (nano::log::type tag); +}; + +nano::nlogger & default_logger (); +} \ No newline at end of file diff --git a/nano/lib/logging_enums.cpp b/nano/lib/logging_enums.cpp new file mode 100644 index 0000000000..a82996aa70 --- /dev/null +++ b/nano/lib/logging_enums.cpp @@ -0,0 +1,91 @@ +#define MAGIC_ENUM_RANGE_MIN 0 +#define MAGIC_ENUM_RANGE_MAX 256 + +#include +#include + +#include + +std::string_view nano::log::to_string (nano::log::type tag) +{ + return magic_enum::enum_name (tag); +} + +std::string_view nano::log::to_string (nano::log::detail detail) +{ + return magic_enum::enum_name (detail); +} + +std::string_view nano::log::to_string (nano::log::level level) +{ + return magic_enum::enum_name (level); +} + +const std::vector & nano::log::all_levels () +{ + static std::vector all = [] () { + std::vector result; + for (auto const & lvl : magic_enum::enum_values ()) + { + result.push_back (lvl); + } + return result; + }(); + return all; +} + +const std::vector & nano::log::all_types () +{ + static std::vector all = [] () { + std::vector result; + for (auto const & lvl : magic_enum::enum_values ()) + { + result.push_back (lvl); + } + return result; + }(); + return all; +} + +nano::log::level nano::log::to_level (std::string_view name) +{ + auto value = magic_enum::enum_cast (name); + if (value.has_value ()) + { + return value.value (); + } + else + { + auto all_levels_str = nano::util::join (nano::log::all_levels (), ", ", [] (auto const & lvl) { + return to_string (lvl); + }); + + throw std::invalid_argument ("Invalid log level: " + std::string (name) + ". Must be one of: " + all_levels_str); + } +} + +nano::log::type nano::log::to_type (std::string_view name) +{ + auto value = magic_enum::enum_cast (name); + if (value.has_value ()) + { + return value.value (); + } + else + { + throw std::invalid_argument ("Invalid log type: " + std::string (name)); + } +} + +nano::log::detail nano::log::to_detail (std::string_view name) +{ + auto value = magic_enum::enum_cast (name); + if (value.has_value ()) + { + return value.value (); + } + else + { + throw std::invalid_argument ("Invalid log detail: " + std::string (name)); + } +} \ No newline at end of file diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp new file mode 100644 index 0000000000..83f49fafa1 --- /dev/null +++ b/nano/lib/logging_enums.hpp @@ -0,0 +1,140 @@ +#pragma once + +#include +#include +#include + +namespace nano::log +{ +enum class level +{ + trace, + debug, + info, + warn, + error, + critical, + off, +}; + +enum class type +{ + all = 0, // reserved + + generic, + config, + logging, + node, + node_wrapper, + daemon, + daemon_rpc, + daemon_wallet, + wallet, + qt, + rpc, + rpc_connection, + rpc_callbacks, + rpc_request, + ipc, + ipc_server, + websocket, + tls, + active_transactions, + election, + blockprocessor, + network, + channel, + socket, + socket_server, + tcp, + tcp_server, + prunning, + conf_processor_bounded, + conf_processor_unbounded, + distributed_work, + epoch_upgrader, + opencl_work, + upnp, + repcrawler, + lmdb, + rocksdb, + txn_tracker, + gap_cache, + vote_processor, + bulk_pull_client, + bulk_pull_server, + bulk_pull_account_client, + bulk_pull_account_server, + bulk_push_client, + bulk_push_server, + frontier_req_client, + frontier_req_server, + bootstrap, + bootstrap_lazy, + bootstrap_legacy, +}; + +enum class detail +{ + all = 0, // reserved + + // node + process_confirmed, + + // active_transactions + active_started, + active_stopped, + + // election + election_confirmed, + election_expired, + + // blockprocessor + block_processed, + + // vote_processor + vote_processed, + + // network + message_received, + message_sent, + message_dropped, + + // bulk pull/push + pulled_block, + sending_block, + sending_pending, + sending_frontier, + requesting_account_or_head, + requesting_pending, + +}; + +// TODO: Additionally categorize logs by categories which can be enabled/disabled independently +enum class category +{ + all = 0, // reserved + + work_generation, + // ... +}; +} + +namespace nano::log +{ +std::string_view to_string (nano::log::type); +std::string_view to_string (nano::log::detail); +std::string_view to_string (nano::log::level); + +/// @throw std::invalid_argument if the input string does not match a log::level +nano::log::level to_level (std::string_view); + +/// @throw std::invalid_argument if the input string does not match a log::type +nano::log::type to_type (std::string_view); + +/// @throw std::invalid_argument if the input string does not match a log::detail +nano::log::detail to_detail (std::string_view); + +std::vector const & all_levels (); +std::vector const & all_types (); +} From 24b0d9abe4456002973b1c2fed5a047026f1980b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 9 Jan 2024 21:53:24 +0100 Subject: [PATCH 007/190] Replace legacy logging calls --- nano/core_test/block_store.cpp | 96 ++++----- nano/core_test/bootstrap.cpp | 6 +- nano/core_test/bootstrap_ascending.cpp | 21 +- nano/core_test/confirmation_height.cpp | 31 ++- nano/core_test/core_test_main.cc | 3 +- nano/core_test/ledger.cpp | 25 +-- nano/core_test/message.cpp | 16 -- nano/core_test/node.cpp | 21 +- nano/core_test/processor_service.cpp | 5 +- nano/core_test/work_pool.cpp | 4 +- nano/lib/blocks.cpp | 6 + nano/lib/blocks.hpp | 3 + nano/lib/config.cpp | 24 +++ nano/lib/config.hpp | 2 + nano/lib/logging_enums.hpp | 1 + nano/lib/numbers.cpp | 21 ++ nano/lib/numbers.hpp | 7 + nano/lib/stats_enums.hpp | 8 +- nano/lib/tlsconfig.cpp | 8 +- nano/lib/tlsconfig.hpp | 4 +- nano/lib/utility.hpp | 41 ++++ nano/load_test/entry.cpp | 2 + nano/nano_node/daemon.cpp | 58 +++--- nano/nano_node/daemon.hpp | 8 +- nano/nano_node/entry.cpp | 23 ++- nano/nano_rpc/entry.cpp | 21 +- nano/nano_wallet/entry.cpp | 22 +- nano/node/active_transactions.cpp | 16 +- nano/node/blockprocessor.cpp | 85 ++------ nano/node/blockprocessor.hpp | 1 + nano/node/bootstrap/bootstrap_attempt.cpp | 7 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 150 ++++---------- nano/node/bootstrap/bootstrap_bulk_push.cpp | 42 +--- nano/node/bootstrap/bootstrap_connections.cpp | 53 ++--- nano/node/bootstrap/bootstrap_frontier.cpp | 50 ++--- nano/node/bootstrap/bootstrap_lazy.cpp | 6 +- nano/node/bootstrap/bootstrap_legacy.cpp | 36 ++-- nano/node/cli.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 29 +-- nano/node/confirmation_height_bounded.hpp | 7 +- nano/node/confirmation_height_processor.cpp | 6 +- nano/node/confirmation_height_processor.hpp | 5 +- nano/node/confirmation_height_unbounded.cpp | 18 +- nano/node/confirmation_height_unbounded.hpp | 7 +- nano/node/distributed_work.cpp | 84 +++++--- nano/node/election.cpp | 27 --- nano/node/election.hpp | 5 +- nano/node/epoch_upgrader.cpp | 26 ++- nano/node/epoch_upgrader.hpp | 6 +- nano/node/gap_cache.cpp | 2 +- nano/node/ipc/ipc_broker.cpp | 12 +- nano/node/ipc/ipc_server.cpp | 70 +++---- nano/node/json_handler.cpp | 5 +- nano/node/make_store.cpp | 2 +- nano/node/make_store.hpp | 4 +- nano/node/messages.cpp | 168 +++++++-------- nano/node/messages.hpp | 4 +- nano/node/network.cpp | 93 ++------- nano/node/network.hpp | 4 +- nano/node/node.cpp | 195 ++++++++---------- nano/node/node.hpp | 8 +- nano/node/nodeconfig.hpp | 2 + nano/node/openclwork.cpp | 57 ++--- nano/node/openclwork.hpp | 8 +- nano/node/portmapping.cpp | 84 +++++--- nano/node/repcrawler.cpp | 19 +- nano/node/transport/channel.cpp | 13 +- nano/node/transport/message_deserializer.cpp | 77 +------ nano/node/transport/message_deserializer.hpp | 8 +- nano/node/transport/socket.cpp | 28 ++- nano/node/transport/socket.hpp | 2 + nano/node/transport/tcp.cpp | 61 +++--- nano/node/transport/tcp_server.cpp | 117 +++++------ nano/node/vote_processor.cpp | 17 +- nano/node/vote_processor.hpp | 6 +- nano/node/wallet.cpp | 35 ++-- nano/node/websocket.cpp | 87 ++++---- nano/node/websocket.hpp | 32 +-- nano/node/websocket_stream.cpp | 10 + nano/node/websocket_stream.hpp | 2 + nano/qt/qt.cpp | 4 +- nano/qt_test/entry.cpp | 3 + nano/qt_test/qt.cpp | 6 +- nano/rpc/rpc.cpp | 13 +- nano/rpc/rpc.hpp | 4 +- nano/rpc/rpc_connection.cpp | 19 +- nano/rpc/rpc_connection.hpp | 5 +- nano/rpc/rpc_handler.cpp | 15 +- nano/rpc/rpc_handler.hpp | 6 +- nano/rpc/rpc_secure.cpp | 4 +- nano/rpc_test/entry.cpp | 3 + nano/secure/common.cpp | 1 + nano/secure/ledger.cpp | 5 +- nano/secure/ledger.hpp | 3 - nano/secure/vote.cpp | 21 +- nano/secure/vote.hpp | 11 - nano/slow_test/entry.cpp | 3 + nano/slow_test/node.cpp | 10 +- nano/store/lmdb/lmdb.cpp | 50 +++-- nano/store/lmdb/lmdb.hpp | 8 +- nano/store/lmdb/transaction.cpp | 13 +- nano/store/lmdb/transaction_impl.hpp | 9 +- nano/store/rocksdb/rocksdb.cpp | 25 ++- nano/store/rocksdb/rocksdb.hpp | 10 +- nano/test_common/ledger.cpp | 2 +- nano/test_common/ledger.hpp | 2 +- nano/test_common/system.cpp | 3 +- nano/test_common/system.hpp | 1 + 108 files changed, 1252 insertions(+), 1394 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 59c8092450..db456d6bbc 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -27,7 +27,7 @@ using namespace std::chrono_literals; TEST (block_store, construction) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); } @@ -102,7 +102,7 @@ TEST (block_store, sideband_serialization) TEST (block_store, add_item) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -133,7 +133,7 @@ TEST (block_store, add_item) TEST (block_store, clear_successor) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -180,7 +180,7 @@ TEST (block_store, clear_successor) TEST (block_store, add_nonempty_block) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -207,7 +207,7 @@ TEST (block_store, add_nonempty_block) TEST (block_store, add_two_items) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -253,7 +253,7 @@ TEST (block_store, add_two_items) TEST (block_store, add_receive) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -289,7 +289,7 @@ TEST (block_store, add_receive) TEST (block_store, add_pending) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -307,7 +307,7 @@ TEST (block_store, add_pending) TEST (block_store, pending_iterator) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -332,7 +332,7 @@ TEST (block_store, pending_iterator) */ TEST (block_store, pending_iterator_comparison) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -375,7 +375,7 @@ TEST (block_store, pending_iterator_comparison) TEST (block_store, genesis) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger_cache ledger_cache; @@ -403,7 +403,7 @@ TEST (block_store, genesis) TEST (block_store, empty_accounts) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); @@ -414,7 +414,7 @@ TEST (block_store, empty_accounts) TEST (block_store, one_block) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -435,7 +435,7 @@ TEST (block_store, one_block) TEST (block_store, empty_bootstrap) { nano::test::system system{}; - nano::logger_mt logger; + nano::nlogger logger; nano::unchecked_map unchecked{ system.stats, false }; size_t count = 0; unchecked.for_each ([&count] (nano::unchecked_key const & key, nano::unchecked_info const & info) { @@ -446,7 +446,7 @@ TEST (block_store, empty_bootstrap) TEST (block_store, unchecked_begin_search) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key0; @@ -471,7 +471,7 @@ TEST (block_store, unchecked_begin_search) TEST (block_store, frontier_retrieval) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1{}; @@ -486,7 +486,7 @@ TEST (block_store, frontier_retrieval) TEST (block_store, one_account) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account{}; @@ -513,7 +513,7 @@ TEST (block_store, one_account) TEST (block_store, two_block) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -551,7 +551,7 @@ TEST (block_store, two_block) TEST (block_store, two_account) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); @@ -593,7 +593,7 @@ TEST (block_store, two_account) TEST (block_store, latest_find) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); @@ -627,7 +627,7 @@ TEST (mdb_block_store, supported_version_upgrades) } // Check that upgrading from an unsupported version is not supported auto path (nano::unique_path () / "data.ldb"); - nano::logger_mt logger; + nano::nlogger logger; { nano::store::lmdb::component store (logger, path, nano::dev::constants); nano::stats stats; @@ -671,7 +671,7 @@ TEST (mdb_block_store, bad_path) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::logger_mt logger; + nano::nlogger logger; try { auto path = nano::unique_path (); @@ -696,14 +696,14 @@ TEST (block_store, DISABLED_already_open) // File can be shared std::ofstream file; file.open (path.string ().c_str ()); ASSERT_TRUE (file.is_open ()); - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (store->init_error ()); } TEST (block_store, roots) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -745,7 +745,7 @@ TEST (block_store, roots) TEST (block_store, pending_exists) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::pending_key two (2, 0); @@ -758,7 +758,7 @@ TEST (block_store, pending_exists) TEST (block_store, latest_exists) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account two (2); @@ -772,7 +772,7 @@ TEST (block_store, latest_exists) TEST (block_store, large_iteration) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); std::unordered_set accounts1; @@ -811,7 +811,7 @@ TEST (block_store, large_iteration) TEST (block_store, frontier) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -826,7 +826,7 @@ TEST (block_store, frontier) TEST (block_store, block_replace) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -858,7 +858,7 @@ TEST (block_store, block_replace) TEST (block_store, block_count) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { @@ -883,7 +883,7 @@ TEST (block_store, block_count) TEST (block_store, account_count) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { @@ -899,7 +899,7 @@ TEST (block_store, account_count) TEST (block_store, cemented_count_cache) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -910,7 +910,7 @@ TEST (block_store, cemented_count_cache) TEST (block_store, block_random) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); { nano::ledger_cache ledger_cache; @@ -925,7 +925,7 @@ TEST (block_store, block_random) TEST (block_store, pruned_random) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -952,7 +952,7 @@ TEST (block_store, pruned_random) TEST (block_store, state_block) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::keypair key1; @@ -999,7 +999,7 @@ TEST (mdb_block_store, sideband_height) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::logger_mt logger; + nano::nlogger logger; nano::keypair key1; nano::keypair key2; nano::keypair key3; @@ -1152,7 +1152,7 @@ TEST (mdb_block_store, sideband_height) TEST (block_store, peers) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1250,7 +1250,7 @@ TEST (block_store, endpoint_key_byte_order) TEST (block_store, online_weight) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); { @@ -1285,7 +1285,7 @@ TEST (block_store, online_weight) TEST (block_store, pruned_blocks) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1372,7 +1372,7 @@ TEST (mdb_block_store, upgrade_v21_v22) } auto path (nano::unique_path () / "data.ldb"); - nano::logger_mt logger; + nano::nlogger logger; nano::stats stats; auto const check_correct_state = [&] () { nano::store::lmdb::component store (logger, path, nano::dev::constants); @@ -1411,7 +1411,7 @@ TEST (rocksdb_block_store, upgrade_v21_v22) } auto const path = nano::unique_path () / "rocksdb"; - nano::logger_mt logger; + nano::nlogger logger; nano::stats stats; auto const check_correct_state = [&] () { nano::store::rocksdb::component store (logger, path, nano::dev::constants); @@ -1471,7 +1471,7 @@ TEST (mdb_block_store, upgrade_backup) }; { - nano::logger_mt logger; + nano::nlogger logger; nano::store::lmdb::component store (logger, path, nano::dev::constants); auto transaction (store.tx_begin_write ()); store.version.put (transaction, store.version_minimum); @@ -1479,7 +1479,7 @@ TEST (mdb_block_store, upgrade_backup) ASSERT_EQ (get_backup_path ().string (), dir.string ()); // Now do the upgrade and confirm that backup is saved - nano::logger_mt logger; + nano::nlogger logger; nano::store::lmdb::component store (logger, path, nano::dev::constants, nano::txn_tracking_config{}, std::chrono::seconds (5), nano::lmdb_config{}, true); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); @@ -1496,7 +1496,7 @@ TEST (block_store, confirmation_height) GTEST_SKIP (); } auto path (nano::unique_path ()); - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, path, nano::dev::constants); nano::account account1{}; @@ -1542,7 +1542,7 @@ TEST (block_store, final_vote) GTEST_SKIP (); } auto path (nano::unique_path ()); - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, path, nano::dev::constants); { @@ -1567,7 +1567,7 @@ TEST (block_store, final_vote) TEST (block_store, incompatible_version) { auto path (nano::unique_path ()); - nano::logger_mt logger; + nano::nlogger logger; { auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_FALSE (store->init_error ()); @@ -1590,7 +1590,7 @@ TEST (block_store, incompatible_version) TEST (block_store, reset_renew_existing_transaction) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1630,7 +1630,7 @@ TEST (block_store, reset_renew_existing_transaction) TEST (block_store, rocksdb_force_test_env_variable) { - nano::logger_mt logger; + nano::nlogger logger; // Set environment variable constexpr auto env_var = "TEST_USE_ROCKSDB"; @@ -1660,7 +1660,7 @@ TEST (rocksdb_block_store, tombstone_count) GTEST_SKIP (); } nano::test::system system; - nano::logger_mt logger; + nano::nlogger logger; auto store = std::make_unique (logger, nano::unique_path () / "rocksdb", nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 963385d594..f2297aff71 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -944,7 +944,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (5, node1->ledger.cache.cemented_count); // Pruning action - node1->ledger_pruning (2, false, false); + node1->ledger_pruning (2, false); ASSERT_EQ (9, node0->ledger.cache.block_count); ASSERT_EQ (0, node0->ledger.cache.pruned_count); ASSERT_EQ (5, node1->ledger.cache.block_count); @@ -1326,7 +1326,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (5, node1->ledger.cache.cemented_count); // Pruning action - node1->ledger_pruning (2, false, false); + node1->ledger_pruning (2, false); ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (1, node1->ledger.cache.pruned_count); ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send1->hash ())); // true for pruned @@ -2031,7 +2031,7 @@ TEST (bulk, DISABLED_genesis_pruning) election->force_confirm (); } ASSERT_TIMELY (2s, node1->active.empty () && node1->block_confirmed (send3->hash ())); - node1->ledger_pruning (2, false, false); + node1->ledger_pruning (2, false); ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (4, node1->ledger.cache.block_count); ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send1->hash ())); // true for pruned diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index f90e5d2a7c..7599ed5c5f 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -24,7 +25,7 @@ nano::block_hash random_hash () TEST (account_sets, construction) { nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -34,7 +35,7 @@ TEST (account_sets, empty_blocked) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -45,7 +46,7 @@ TEST (account_sets, block) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -57,7 +58,7 @@ TEST (account_sets, unblock) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -71,7 +72,7 @@ TEST (account_sets, priority_base) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -82,7 +83,7 @@ TEST (account_sets, priority_blocked) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -95,7 +96,7 @@ TEST (account_sets, priority_unblock_keep) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -113,7 +114,7 @@ TEST (account_sets, priority_up_down) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -128,7 +129,7 @@ TEST (account_sets, priority_down_sat) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -141,7 +142,7 @@ TEST (account_sets, saturate_priority) { nano::account account{ 1 }; nano::stats stats; - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index f0db5471b6..65ec67fabf 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -1157,8 +1158,7 @@ TEST (confirmation_heightDeathTest, rollback_added_block) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::logger_mt logger; - nano::logging logging; + nano::nlogger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1184,13 +1184,13 @@ TEST (confirmation_heightDeathTest, rollback_added_block) uint64_t batch_write_size = 2048; std::atomic stopped{ false }; nano::confirmation_height_unbounded unbounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); // Processing a block which doesn't exist should bail ASSERT_DEATH_IF_SUPPORTED (unbounded_processor.process (send), ""); nano::confirmation_height_bounded bounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); // Processing a block which doesn't exist should bail ASSERT_DEATH_IF_SUPPORTED (bounded_processor.process (send), ""); } @@ -1249,8 +1249,7 @@ TEST (confirmation_heightDeathTest, modified_chain) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::logging logging; - nano::logger_mt logger; + nano::nlogger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1277,7 +1276,7 @@ TEST (confirmation_heightDeathTest, modified_chain) uint64_t batch_write_size = 2048; std::atomic stopped{ false }; nano::confirmation_height_bounded bounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { // This reads the blocks in the account, but prevents any writes from occuring yet @@ -1296,7 +1295,7 @@ TEST (confirmation_heightDeathTest, modified_chain) store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { // This reads the blocks in the account, but prevents any writes from occuring yet @@ -1327,8 +1326,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::logging logging; - nano::logger_mt logger; + nano::nlogger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1366,7 +1364,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) uint64_t batch_write_size = 2048; std::atomic stopped{ false }; nano::confirmation_height_unbounded unbounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { // This reads the blocks in the account, but prevents any writes from occuring yet @@ -1386,7 +1384,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { // This reads the blocks in the account, but prevents any writes from occuring yet @@ -2039,7 +2037,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::logger_mt logger; + nano::nlogger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -2048,7 +2046,6 @@ TEST (confirmation_height, unbounded_block_cache_iteration) nano::write_database_queue write_database_queue (false); boost::latch initialized_latch{ 0 }; nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; - nano::logging logging; nano::keypair key1; nano::block_builder builder; auto send = builder @@ -2074,7 +2071,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); } - nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logging, logger, initialized_latch, nano::confirmation_height_mode::unbounded); + nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded); nano::timer<> timer; timer.start (); { @@ -2103,7 +2100,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) TEST (confirmation_height, pruned_source) { - nano::logger_mt logger; + nano::nlogger logger; nano::logging logging; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); @@ -2178,7 +2175,7 @@ TEST (confirmation_height, pruned_source) std::atomic stopped{ false }; bool first_time{ true }; nano::confirmation_height_bounded bounded_processor ( - ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [&] (auto const & cemented_blocks_a) { + ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [&] (auto const & cemented_blocks_a) { if (first_time) { // Prune the send diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index 6f5c4fc499..883ed8e209 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -1,5 +1,6 @@ #include "gtest/gtest.h" +#include #include #include #include @@ -19,7 +20,7 @@ void force_nano_dev_network (); GTEST_API_ int main (int argc, char ** argv) { - printf ("Running main() from core_test_main.cc\n"); + nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 63e8682ed3..70841d5eee 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -817,7 +818,7 @@ TEST (ledger, representation) TEST (ledger, double_open) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -4161,7 +4162,7 @@ TEST (ledger, block_hash_account_conflict) TEST (ledger, could_fit) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -4799,7 +4800,7 @@ TEST (ledger, dependents_confirmed) TEST (ledger, dependents_confirmed_pruning) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -4989,7 +4990,7 @@ TEST (ledger, cache) TEST (ledger, pruning_action) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5073,7 +5074,7 @@ TEST (ledger, pruning_action) TEST (ledger, pruning_large_chain) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5128,7 +5129,7 @@ TEST (ledger, pruning_large_chain) TEST (ledger, pruning_source_rollback) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5216,7 +5217,7 @@ TEST (ledger, pruning_source_rollback) TEST (ledger, pruning_source_rollback_legacy) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5329,7 +5330,7 @@ TEST (ledger, pruning_source_rollback_legacy) TEST (ledger, pruning_process_error) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5376,7 +5377,7 @@ TEST (ledger, pruning_process_error) TEST (ledger, pruning_legacy_blocks) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5462,7 +5463,7 @@ TEST (ledger, pruning_legacy_blocks) TEST (ledger, pruning_safe_functions) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5523,7 +5524,7 @@ TEST (ledger, pruning_safe_functions) TEST (ledger, hash_root_random) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5587,7 +5588,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) { nano::test::system system{}; auto path = nano::unique_path (); - nano::logger_mt logger{}; + nano::nlogger logger; boost::asio::ip::address_v6 address (boost::asio::ip::make_address_v6 ("::ffff:127.0.0.1")); uint16_t port = 100; nano::store::lmdb::component store{ logger, path / "data.ldb", nano::dev::constants }; diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 29e70e371c..c26e359a45 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -362,22 +362,6 @@ TEST (message, confirm_req_hash_batch_serialization_v2) ASSERT_TRUE (header.confirm_is_v2 ()); } -// this unit test checks that conversion of message_header to string works as expected -TEST (message, message_header_to_string) -{ - // calculate expected string - int maxver = nano::dev::network_params.network.protocol_version; - int minver = nano::dev::network_params.network.protocol_version_min; - std::stringstream ss; - ss << "NetID: 5241(dev), VerMaxUsingMin: " << maxver << "/" << maxver << "/" << minver << ", MsgType: 2(keepalive), Extensions: 0000"; - auto expected_str = ss.str (); - - // check expected vs real - nano::keepalive keepalive_msg{ nano::dev::network_params.network }; - std::string header_string = keepalive_msg.header.to_string (); - ASSERT_EQ (expected_str, header_string); -} - /** * Test that a confirm_ack can encode an empty hash set */ diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 239d29d300..b64d3d4cfd 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -3300,7 +3301,7 @@ TEST (node, dont_write_lock_node) std::promise write_lock_held_promise; std::promise finished_promise; std::thread ([&path, &write_lock_held_promise, &finished_promise] () { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, path, nano::dev::constants, false, true); { nano::ledger_cache ledger_cache; @@ -4230,13 +4231,13 @@ TEST (node, pruning_age) ASSERT_EQ (3, node1.ledger.cache.block_count); // Pruning with default age 1 day - node1.ledger_pruning (1, true, false); + node1.ledger_pruning (1, true); ASSERT_EQ (0, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); // Pruning with max age 0 node1.config.max_pruning_age = std::chrono::seconds{ 0 }; - node1.ledger_pruning (1, true, false); + node1.ledger_pruning (1, true); ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); @@ -4293,13 +4294,13 @@ TEST (node, pruning_depth) ASSERT_EQ (3, node1.ledger.cache.block_count); // Pruning with default depth (unlimited) - node1.ledger_pruning (1, true, false); + node1.ledger_pruning (1, true); ASSERT_EQ (0, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); // Pruning with max depth 1 node1.config.max_pruning_depth = 1; - node1.ledger_pruning (1, true, false); + node1.ledger_pruning (1, true); ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); @@ -4310,7 +4311,7 @@ TEST (node, pruning_depth) TEST (node_config, node_id_private_key_persistence) { - nano::logger_mt logger; + nano::test::system system; // create the directory and the file auto path = nano::unique_path (); @@ -4318,19 +4319,19 @@ TEST (node_config, node_id_private_key_persistence) auto priv_key_filename = path / "node_id_private.key"; // check that the key generated is random when the key does not exist - nano::keypair kp1 = nano::load_or_create_node_id (path, logger); + nano::keypair kp1 = nano::load_or_create_node_id (path, system.nlogger); std::filesystem::remove (priv_key_filename); - nano::keypair kp2 = nano::load_or_create_node_id (path, logger); + nano::keypair kp2 = nano::load_or_create_node_id (path, system.nlogger); ASSERT_NE (kp1.prv, kp2.prv); // check that the key persists - nano::keypair kp3 = nano::load_or_create_node_id (path, logger); + nano::keypair kp3 = nano::load_or_create_node_id (path, system.nlogger); ASSERT_EQ (kp2.prv, kp3.prv); // write the key file manually and check that right key is loaded std::ofstream ofs (priv_key_filename.string (), std::ofstream::out | std::ofstream::trunc); ofs << "3F28D035B8AA75EA53DF753BFD065CF6138E742971B2C99B84FD8FE328FED2D9" << std::flush; ofs.close (); - nano::keypair kp4 = nano::load_or_create_node_id (path, logger); + nano::keypair kp4 = nano::load_or_create_node_id (path, system.nlogger); ASSERT_EQ (kp4.prv, nano::keypair ("3F28D035B8AA75EA53DF753BFD065CF6138E742971B2C99B84FD8FE328FED2D9").prv); } diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 42893a97d0..6e48598762 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -10,7 +11,7 @@ TEST (processor_service, bad_send_signature) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -36,7 +37,7 @@ TEST (processor_service, bad_send_signature) TEST (processor_service, bad_receive_signature) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 99fafac728..44e726a8b9 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -92,7 +92,7 @@ TEST (work, opencl) { nano::logging logging; logging.init (nano::unique_path ()); - nano::logger_mt logger; + nano::nlogger logger; bool error (false); nano::opencl_environment environment (error); ASSERT_TRUE (!error || !nano::opencl_loaded); diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 15881b3e50..7a77dfc3b7 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -11,6 +11,7 @@ #include #include +#include /** Compare blocks, first by type, then content. This is an optimization over dynamic_cast, which is very slow on some platforms. */ namespace @@ -1864,3 +1865,8 @@ bool nano::block_sideband::deserialize (nano::stream & stream_a, nano::block_typ return result; } + +std::string_view nano::to_string (nano::block_type type) +{ + return magic_enum::enum_name (type); +} diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 5a9ab168bc..acc44601d5 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -29,6 +29,9 @@ enum class block_type : uint8_t change = 5, state = 6 }; + +std::string_view to_string (block_type); + class block_details { static_assert (std::is_same::type, uint8_t> (), "Epoch enum is not the proper type"); diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index 506a2cb3e1..f722b0e66a 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include @@ -356,6 +357,26 @@ uint32_t nano::test_scan_wallet_reps_delay () return boost::lexical_cast (test_env); } +std::string_view nano::to_string (nano::networks network) +{ + switch (network) + { + case nano::networks::invalid: + return "invalid"; + case nano::networks::nano_beta_network: + return "beta"; + case nano::networks::nano_dev_network: + return "dev"; + case nano::networks::nano_live_network: + return "live"; + case nano::networks::nano_test_network: + return "test"; + // default case intentionally omitted to cause warnings for unhandled enums + } + + return "n/a"; +} + nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides) { std::stringstream config_overrides_stream; @@ -383,10 +404,12 @@ nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_file // First try to load config from the current working directory, then from the node data directory if (auto toml = try_load_toml (config_filename); toml) { + nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from current working directory", config_filename.string ()); return *toml; } if (auto toml = try_load_toml (data_path / config_filename); toml) { + nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from node data directory ({})", config_filename.string (), data_path.string ()); return *toml; } @@ -397,5 +420,6 @@ nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_file { throw std::runtime_error (error.get_message ()); } + nano::default_logger ().info (nano::log::type::config, "Config for `{}` not found, using default configuration", config_filename.string ()); return toml; } diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index f1e94c2383..d319d0aff5 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -129,6 +129,8 @@ enum class networks : uint16_t nano_test_network = 0x5258, // 'R', 'X' }; +std::string_view to_string (nano::networks); + enum class work_version { unspecified, diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index 83f49fafa1..64969fd34e 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -48,6 +48,7 @@ enum class type socket_server, tcp, tcp_server, + tcp_listener, prunning, conf_processor_bounded, conf_processor_unbounded, diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp index 65cb8ac86d..f33d6f3cb3 100644 --- a/nano/lib/numbers.cpp +++ b/nano/lib/numbers.cpp @@ -894,6 +894,27 @@ std::string nano::to_string (double const value_a, int const precision_a) return stream.str (); } +std::ostream & nano::operator<< (std::ostream & os, const uint128_union & val) +{ + // TODO: Replace with streaming implementation + os << val.to_string (); + return os; +} + +std::ostream & nano::operator<< (std::ostream & os, const uint256_union & val) +{ + // TODO: Replace with streaming implementation + os << val.to_string (); + return os; +} + +std::ostream & nano::operator<< (std::ostream & os, const uint512_union & val) +{ + // TODO: Replace with streaming implementation + os << val.to_string (); + return os; +} + #ifdef _WIN32 #pragma warning(push) #pragma warning(disable : 4146) // warning C4146: unary minus operator applied to unsigned type, result still unsigned diff --git a/nano/lib/numbers.hpp b/nano/lib/numbers.hpp index d73310d1b4..3021524c4c 100644 --- a/nano/lib/numbers.hpp +++ b/nano/lib/numbers.hpp @@ -4,6 +4,7 @@ #include #include +#include namespace nano { @@ -61,6 +62,7 @@ class amount : public uint128_union using uint128_union::uint128_union; }; class raw_key; + class uint256_union { public: @@ -265,6 +267,11 @@ std::string to_string_hex (uint64_t const); std::string to_string_hex (uint16_t const); bool from_string_hex (std::string const &, uint64_t &); +/* Printing adapters */ +std::ostream & operator<< (std::ostream & os, const uint128_union & val); +std::ostream & operator<< (std::ostream & os, const uint256_union & val); +std::ostream & operator<< (std::ostream & os, const uint512_union & val); + /** * Convert a double to string in fixed format * @param precision_a (optional) use a specific precision (default is the maximum) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 7473d85c66..ff9ef58190 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -21,6 +21,8 @@ enum class type : uint8_t http_callback, ipc, tcp, + channel, + socket, confirmation_height, confirmation_observer, drop, @@ -311,7 +313,7 @@ enum class dir : uint8_t namespace nano { -std::string_view to_string (stat::type type); -std::string_view to_string (stat::detail detail); -std::string_view to_string (stat::dir dir); +std::string_view to_string (stat::type); +std::string_view to_string (stat::detail); +std::string_view to_string (stat::dir); } diff --git a/nano/lib/tlsconfig.cpp b/nano/lib/tlsconfig.cpp index 064fce24d8..898103763b 100644 --- a/nano/lib/tlsconfig.cpp +++ b/nano/lib/tlsconfig.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -138,7 +138,7 @@ namespace } #endif -nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger_mt & logger_a, std::vector const & config_overrides) +nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::nlogger & nlogger, std::vector const & config_overrides) { nano::error error; auto toml_config_path = nano::get_tls_toml_config_path (data_path_a); @@ -176,9 +176,7 @@ nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nan #ifdef NANO_SECURE_RPC load_certs (config_a, logger_a); #else - auto msg ("https or wss is enabled in the TLS configuration, but the node is not built with NANO_SECURE_RPC"); - std::cerr << msg << std::endl; - logger_a.always_log (msg); + nlogger.critical (nano::log::type::tls, "HTTPS or WSS is enabled in the TLS configuration, but the node is not built with NANO_SECURE_RPC"); std::exit (1); #endif } diff --git a/nano/lib/tlsconfig.hpp b/nano/lib/tlsconfig.hpp index 3afc605327..d7d18f4202 100644 --- a/nano/lib/tlsconfig.hpp +++ b/nano/lib/tlsconfig.hpp @@ -13,7 +13,7 @@ namespace nano { -class logger_mt; +class nlogger; class jsonconfig; class tomlconfig; @@ -54,5 +54,5 @@ class tls_config final #endif }; -nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger_mt & logger_a, std::vector const & config_overrides = std::vector ()); +nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::nlogger &, std::vector const & config_overrides = std::vector ()); } diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 7155ca4760..5ec06f6e9e 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -3,6 +3,7 @@ #include #include +#include #include #include @@ -10,6 +11,7 @@ #include #include #include +#include #include #include @@ -210,3 +212,42 @@ bool elapsed (nano::clock::time_point const & last, Duration duration) return elapsed (last, duration, nano::clock::now ()); } } + +namespace nano::util +{ +/** + * Joins elements with specified delimiter while transforming those elements via specified transform function + */ +template +std::string join (InputIt first, InputIt last, std::string_view delimiter, Func transform) +{ + bool start = true; + std::stringstream ss; + while (first != last) + { + if (start) + { + start = false; + } + else + { + ss << delimiter << " "; + } + ss << transform (*first); + ++first; + } + return ss.str (); +} + +template +std::string join (Container const & container, std::string_view delimiter, Func transform) +{ + return join (container.begin (), container.end (), delimiter, transform); +} + +template +std::string to_str (T const & val) +{ + return boost::lexical_cast (val); +} +} \ No newline at end of file diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index db0ecc5f47..ea26bee3c6 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -490,6 +491,7 @@ account_info account_info_rpc (boost::asio::io_context & ioc, tcp::resolver::res /** This launches a node and fires a lot of send/recieve RPC requests at it (configurable), then other nodes are tested to make sure they observe these blocks as well. */ int main (int argc, char * const * argv) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); boost::program_options::options_description description ("Command line options"); diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 6344fd8e21..dc16ead8d3 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -20,6 +20,8 @@ #include #include +#include + namespace { void nano_abort_signal_handler (int signum) @@ -59,13 +61,18 @@ volatile sig_atomic_t sig_int_or_term = 0; constexpr std::size_t OPEN_FILE_DESCRIPTORS_LIMIT = 16384; } -void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::node_flags const & flags) +void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flags const & flags) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::daemon_default (), data_path, flags.config_overrides)); + + nlogger.info (nano::log::type::daemon, "Daemon started"); + install_abort_signal_handler (); std::filesystem::create_directories (data_path); boost::system::error_code error_chmod; nano::set_secure_perm_directory (data_path, error_chmod); + std::unique_ptr runner; nano::network_params network_params{ nano::network_constants::active_network }; nano::daemon_config config{ data_path, network_params }; @@ -78,10 +85,9 @@ void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::no if (!error) { config.node.logging.init (data_path); - nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, logger); + error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) { std::cerr << error.get_message () << std::endl; @@ -93,30 +99,25 @@ void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::no } boost::asio::io_context io_ctx; - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, nlogger, config.node.network_params.work)); nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); } : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); try { - // This avoid a blank prompt during any node initialization delays - auto initialization_text = "Starting up Nano node..."; - std::cout << initialization_text << std::endl; - logger.always_log (initialization_text); + // This avoids a blank prompt during any node initialization delays + nlogger.info (nano::log::type::daemon, "Starting up Nano node..."); // Print info about number of logical cores detected, those are used to decide how many IO, worker and signature checker threads to spawn - logger.always_log (boost::format ("Hardware concurrency: %1% ( configured: %2% )") % std::thread::hardware_concurrency () % nano::hardware_concurrency ()); + nlogger.info (nano::log::type::daemon, "Hardware concurrency: {} ( configured: {} )", std::thread::hardware_concurrency (), nano::hardware_concurrency ()); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); auto const file_descriptor_limit = nano::get_file_descriptor_limit (); + nlogger.info (nano::log::type::daemon, "File descriptors limit: {}", file_descriptor_limit); if (file_descriptor_limit < OPEN_FILE_DESCRIPTORS_LIMIT) { - logger.always_log (boost::format ("WARNING: open file descriptors limit is %1%, lower than the %2% recommended. Node was unable to change it.") % file_descriptor_limit % OPEN_FILE_DESCRIPTORS_LIMIT); - } - else - { - logger.always_log (boost::format ("Open file descriptors limit is %1%") % file_descriptor_limit); + nlogger.warn (nano::log::type::daemon, "File descriptors limit is lower than the {} recommended. Node was unable to change it.", OPEN_FILE_DESCRIPTORS_LIMIT); } // for the daemon start up, if the user hasn't specified a port in @@ -133,18 +134,15 @@ void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::no auto network_label = node->network_params.network.get_current_network_as_string (); std::time_t dateTime = std::time (nullptr); - std::cout << "Network: " << network_label << ", version: " << NANO_VERSION_STRING << "\n" - << "Path: " << node->application_path.string () << "\n" - << "Build Info: " << BUILD_INFO << "\n" - << "Database backend: " << node->store.vendor_get () << "\n" - << "Start time: " << std::put_time (std::gmtime (&dateTime), "%c UTC") << std::endl; + nlogger.info (nano::log::type::daemon, "Network: {}", network_label); + nlogger.info (nano::log::type::daemon, "Version: {}", NANO_VERSION_STRING); + nlogger.info (nano::log::type::daemon, "Data path: '{}'", node->application_path.string ()); + nlogger.info (nano::log::type::daemon, "Build info: {}", BUILD_INFO); + nlogger.info (nano::log::type::daemon, "Database backend: {}", node->store.vendor_get ()); + nlogger.info (nano::log::type::daemon, "Start time: {:%c} UTC", fmt::gmtime (dateTime)); - auto voting (node->wallets.reps ().voting); - if (voting > 1) - { - std::cout << "Voting with more than one representative can limit performance: " << voting << " representatives are configured" << std::endl; - } node->start (); + nano::ipc::ipc_server ipc_server (*node, config.rpc); std::unique_ptr rpc_process; std::unique_ptr rpc; @@ -187,7 +185,9 @@ void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::no } debug_assert (!nano::signal_handler_impl); - nano::signal_handler_impl = [&io_ctx] () { + nano::signal_handler_impl = [this, &io_ctx] () { + nlogger.warn (nano::log::type::daemon, "Interrupt signal received, stopping..."); + io_ctx.stop (); sig_int_or_term = 1; }; @@ -219,16 +219,18 @@ void nano_daemon::daemon::run (std::filesystem::path const & data_path, nano::no } else { - std::cerr << "Error initializing node\n"; + nlogger.critical (nano::log::type::daemon, "Error initializing node"); } } catch (std::runtime_error const & e) { - std::cerr << "Error while running node (" << e.what () << ")\n"; + nlogger.critical (nano::log::type::daemon, "Error while running node: {}", e.what ()); } } else { - std::cerr << "Error deserializing config: " << error.get_message () << std::endl; + nlogger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); } + + nlogger.info (nano::log::type::daemon, "Daemon exiting"); } diff --git a/nano/nano_node/daemon.hpp b/nano/nano_node/daemon.hpp index d56a26c907..3b4c232e77 100644 --- a/nano/nano_node/daemon.hpp +++ b/nano/nano_node/daemon.hpp @@ -1,11 +1,13 @@ +#include + namespace nano { class node_flags; -} -namespace nano_daemon -{ + class daemon { + nano::nlogger nlogger; + public: void run (std::filesystem::path const &, nano::node_flags const & flags); }; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 250428f542..c23b4ec9ee 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -53,8 +53,11 @@ class address_library_pair int main (int argc, char * const * argv) { - nano::set_umask (); + nano::set_umask (); // Make sure the process umask is set before any files are created + nano::nlogger::initialize (nano::log_config::cli_default ()); + nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; + boost::program_options::options_description description ("Command line options"); // clang-format off description.add_options () @@ -138,7 +141,7 @@ int main (int argc, char * const * argv) { if (vm.count ("daemon") > 0) { - nano_daemon::daemon daemon; + nano::daemon daemon; nano::node_flags flags; auto flags_ec = nano::update_flags (flags, vm); if (flags_ec) @@ -281,14 +284,14 @@ int main (int argc, char * const * argv) { if (sample.diff > log_threshold) { - node->logger.always_log (sample.get_entry ()); + std::cout << '\t' << sample.get_entry () << '\n'; } } for (auto const & newcomer : newcomers) { if (newcomer.second > log_threshold) { - node->logger.always_log (newcomer_entry (newcomer)); + std::cout << '\t' << newcomer_entry (newcomer) << '\n'; } } } @@ -610,9 +613,9 @@ int main (int argc, char * const * argv) error |= device >= environment.platforms[platform].devices.size (); if (!error) { - nano::logger_mt logger; + nano::nlogger nlogger; nano::opencl_config config (platform, device, threads); - auto opencl (nano::opencl_work::create (true, config, logger, network_params.work)); + auto opencl (nano::opencl_work::create (true, config, nlogger, network_params.work)); nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } @@ -1871,7 +1874,7 @@ int main (int argc, char * const * argv) nano::update_flags (node_flags, vm); nano::inactive_node inactive_node (data_path, node_flags); auto node = inactive_node.node; - node->ledger_pruning (node_flags.block_processor_batch_size != 0 ? node_flags.block_processor_batch_size : 16 * 1024, true, true); + node->ledger_pruning (node_flags.block_processor_batch_size != 0 ? node_flags.block_processor_batch_size : 16 * 1024, true); } else if (vm.count ("debug_stacktrace")) { @@ -1887,7 +1890,11 @@ int main (int argc, char * const * argv) } #endif auto inactive_node = nano::default_inactive_node (data_path, vm); - inactive_node->node->logger.always_log (nano::severity_level::error, "Testing system logger"); + inactive_node->node->nlogger.critical ({}, "Testing system logger (CRITICAL)"); + inactive_node->node->nlogger.error ({}, "Testing system logger (ERROR)"); + inactive_node->node->nlogger.warn ({}, "Testing system logger (WARN)"); + inactive_node->node->nlogger.info ({}, "Testing system logger (INFO)"); + inactive_node->node->nlogger.debug ({}, "Testing system logger (DEBUG)"); } else if (vm.count ("debug_account_versions")) { diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp index 415beb9f5f..84164c0a3a 100644 --- a/nano/nano_rpc/entry.cpp +++ b/nano/nano_rpc/entry.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -34,11 +35,17 @@ void logging_init (std::filesystem::path const & application_path_a) volatile sig_atomic_t sig_int_or_term = 0; +nano::nlogger nlogger{ "rpc_daemon" }; + void run (std::filesystem::path const & data_path, std::vector const & config_overrides) { + nlogger.info (nano::log::type::daemon_rpc, "Daemon started (RPC)"); + std::filesystem::create_directories (data_path); + boost::system::error_code error_chmod; nano::set_secure_perm_directory (data_path, error_chmod); + std::unique_ptr runner; nano::network_params network_params{ nano::network_constants::active_network }; @@ -47,13 +54,12 @@ void run (std::filesystem::path const & data_path, std::vector cons if (!error) { logging_init (data_path); - nano::logger_mt logger; auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, logger); + error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) { - std::cerr << error.get_message () << std::endl; + nlogger.critical (nano::log::type::daemon, "Error reading RPC TLS config: {}", error.get_message ()); std::exit (1); } else @@ -88,19 +94,22 @@ void run (std::filesystem::path const & data_path, std::vector cons } catch (std::runtime_error const & e) { - std::cerr << "Error while running rpc (" << e.what () << ")\n"; + nlogger.critical (nano::log::type::daemon, "Error while running RPC: {}", e.what ()); } } else { - std::cerr << "Error deserializing config: " << error.get_message () << std::endl; + nlogger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); } + + nlogger.info (nano::log::type::daemon_rpc, "Daemon stopped (RPC)"); } } int main (int argc, char * const * argv) { - nano::set_umask (); + nano::set_umask (); // Make sure the process umask is set before any files are created + nano::nlogger::initialize (nano::log_config::cli_default ()); boost::program_options::options_description description ("Command line options"); diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 440e5ddf80..0008cedc7d 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -25,13 +26,18 @@ namespace { +nano::nlogger nlogger{ "wallet_daemon" }; + void show_error (std::string const & message_a) { + nlogger.critical (nano::log::type::daemon, "{}", message_a); + QMessageBox message (QMessageBox::Critical, "Error starting Nano", message_a.c_str ()); message.setModal (true); message.show (); message.exec (); } + void show_help (std::string const & message_a) { QMessageBox message (QMessageBox::NoIcon, "Help", "see launch options "); @@ -68,6 +74,10 @@ nano::error read_wallet_config (nano::wallet_config & config_a, std::filesystem: int run_wallet (QApplication & application, int argc, char * const * argv, std::filesystem::path const & data_path, nano::node_flags const & flags) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::daemon_default (), data_path, flags.config_overrides)); + + nlogger.info (nano::log::type::daemon_wallet, "Daemon started (wallet)"); + int result (0); nano_qt::eventloop_processor processor; boost::system::error_code error_chmod; @@ -100,10 +110,9 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: nano::set_use_memory_pools (config.node.use_memory_pools); config.node.logging.init (data_path); - nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, logger); + error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) { splash->hide (); @@ -121,7 +130,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: std::shared_ptr node; std::shared_ptr gui; nano::set_application_icon (application); - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, nlogger, config.node.network_params.work)); nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } @@ -231,12 +240,17 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: splash->hide (); show_error ("Error deserializing config: " + error.get_message ()); } + + nlogger.info (nano::log::type::daemon_wallet, "Daemon exiting (wallet)"); + return result; } int main (int argc, char * const * argv) { - nano::set_umask (); + nano::set_umask (); // Make sure the process umask is set before any files are created + nano::nlogger::initialize (nano::log_config::cli_default ()); + nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; QApplication application (argc, const_cast (argv)); diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index f3581f5b56..29cdbf3c91 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -300,11 +300,6 @@ void nano::active_transactions::request_confirm (nano::unique_lock solicitor.flush (); lock_a.lock (); - - if (node.config.logging.timing_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Processed %1% elections (%2% were already confirmed) in %3% %4%") % this_loop_target_l % (this_loop_target_l - unconfirmed_count_l) % elapsed.value ().count () % elapsed.unit ())); - } } void nano::active_transactions::cleanup_election (nano::unique_lock & lock_a, std::shared_ptr election) @@ -313,7 +308,6 @@ void nano::active_transactions::cleanup_election (nano::unique_lock debug_assert (lock_a.owns_lock ()); debug_assert (!election->confirmed () || recently_confirmed.exists (election->qualified_root)); - node.stats.inc (completion_type (*election), nano::to_stat_detail (election->behavior ())); // Keep track of election count by election type debug_assert (count_by_behavior[election->behavior ()] > 0); count_by_behavior[election->behavior ()]--; @@ -325,10 +319,15 @@ void nano::active_transactions::cleanup_election (nano::unique_lock (void)erased; debug_assert (erased == 1); } + roots.get ().erase (roots.get ().find (election->qualified_root)); lock_a.unlock (); + + node.stats.inc (completion_type (*election), nano::to_stat_detail (election->behavior ())); + vacancy_update (); + for (auto const & [hash, block] : blocks_l) { // Notify observers about dropped elections & blocks lost confirmed elections @@ -343,11 +342,6 @@ void nano::active_transactions::cleanup_election (nano::unique_lock node.network.publish_filter.clear (block); } } - - if (node.config.logging.election_result_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Election erased for root %1%, confirmed: %2$b") % election->qualified_root.to_string () % election->confirmed ())); - } } nano::stat::type nano::active_transactions::completion_type (nano::election const & election) const diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 6d843fea54..7b455fb76c 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -112,19 +112,17 @@ void nano::block_processor::rollback_competitor (store::write_transaction const if (successor != nullptr && successor->hash () != hash) { // Replace our block with the winner and roll back any dependent blocks - if (node.config.logging.ledger_rollback_logging ()) - { - node.logger.always_log (boost::str (boost::format ("Rolling back %1% and replacing with %2%") % successor->hash ().to_string () % hash.to_string ())); - } + node.nlogger.debug (nano::log::type::blockprocessor, "Rolling back: {} and replacing with: {}", successor->hash ().to_string (), hash.to_string ()); + std::vector> rollback_list; if (node.ledger.rollback (transaction, successor->hash (), rollback_list)) { node.stats.inc (nano::stat::type::ledger, nano::stat::detail::rollback_failed); - node.logger.always_log (nano::severity_level::error, boost::str (boost::format ("Failed to roll back %1% because it or a successor was confirmed") % successor->hash ().to_string ())); + node.nlogger.error (nano::log::type::blockprocessor, "Failed to roll back: {} because it or a successor was confirmed", successor->hash ().to_string ()); } - else if (node.config.logging.ledger_rollback_logging ()) + else { - node.logger.always_log (boost::str (boost::format ("%1% blocks rolled back") % rollback_list.size ())); + node.nlogger.debug (nano::log::type::blockprocessor, "Blocks rolled back: {}", rollback_list.size ()); } // Deleting from votes cache, stop active transaction for (auto & i : rollback_list) @@ -218,10 +216,12 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock auto store_batch_reached = [&number_of_blocks_processed, max = node.store.max_block_write_batch_num ()] { return number_of_blocks_processed >= max; }; while (have_blocks_ready () && (!deadline_reached () || !processor_batch_reached ()) && !store_batch_reached ()) { + // TODO: Cleaner periodical logging if ((blocks.size () + forced.size () > 64) && should_log ()) { - node.logger.always_log (boost::str (boost::format ("%1% blocks (+ %2% forced) in processing queue") % blocks.size () % forced.size ())); + node.nlogger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); } + std::shared_ptr block; nano::block_hash hash (0); bool force (false); @@ -251,10 +251,11 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock } lock_a.unlock (); - if (node.config.logging.timing_logging () && number_of_blocks_processed != 0 && timer_l.stop () > std::chrono::milliseconds (100)) + if (number_of_blocks_processed != 0 && timer_l.stop () > std::chrono::milliseconds (100)) { - node.logger.always_log (boost::str (boost::format ("Processed %1% blocks (%2% blocks were forced) in %3% %4%") % number_of_blocks_processed % number_of_forced_processed % timer_l.value ().count () % timer_l.unit ())); + node.nlogger.debug (nano::log::type::blockprocessor, "Processed {} blocks ({} forced) in {} {}", number_of_blocks_processed, number_of_forced_processed, timer_l.value ().count (), timer_l.unit ()); } + return processed; } @@ -263,16 +264,13 @@ nano::process_return nano::block_processor::process_one (store::write_transactio nano::process_return result; auto hash (block->hash ()); result = node.ledger.process (transaction_a, *block); + + node.stats.inc (nano::stat::type::blockprocessor, to_stat_detail (result.code)); + switch (result.code) { case nano::process_result::progress: { - if (node.config.logging.ledger_logging ()) - { - std::string block_string; - block->serialize_json (block_string, node.config.logging.single_line_record ()); - node.logger.try_log (boost::str (boost::format ("Processing block %1%: %2%") % hash.to_string () % block_string)); - } queue_unchecked (transaction_a, hash); /* For send blocks check epoch open unchecked (gap pending). For state blocks check only send subtype and only if block epoch is not last epoch. @@ -287,120 +285,65 @@ nano::process_return nano::block_processor::process_one (store::write_transactio } case nano::process_result::gap_previous: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Gap previous for: %1%") % hash.to_string ())); - } node.unchecked.put (block->previous (), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous); break; } case nano::process_result::gap_source: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Gap source for: %1%") % hash.to_string ())); - } node.unchecked.put (node.ledger.block_source (transaction_a, *block), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } case nano::process_result::gap_epoch_open_pending: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Gap pending entries for epoch open: %1%") % hash.to_string ())); - } node.unchecked.put (block->account (), block); // Specific unchecked key starting with epoch open block account public key node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } case nano::process_result::old: { - if (node.config.logging.ledger_duplicate_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Old for: %1%") % hash.to_string ())); - } node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old); break; } case nano::process_result::bad_signature: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Bad signature for: %1%") % hash.to_string ())); - } break; } case nano::process_result::negative_spend: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Negative spend for: %1%") % hash.to_string ())); - } break; } case nano::process_result::unreceivable: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Unreceivable for: %1%") % hash.to_string ())); - } break; } case nano::process_result::fork: { node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork); - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Fork for: %1% root: %2%") % hash.to_string () % block->root ().to_string ())); - } break; } case nano::process_result::opened_burn_account: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Rejecting open block for burn account: %1%") % hash.to_string ())); - } break; } case nano::process_result::balance_mismatch: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Balance mismatch for: %1%") % hash.to_string ())); - } break; } case nano::process_result::representative_mismatch: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Representative mismatch for: %1%") % hash.to_string ())); - } break; } case nano::process_result::block_position: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Block %1% cannot follow predecessor %2%") % hash.to_string () % block->previous ().to_string ())); - } break; } case nano::process_result::insufficient_work: { - if (node.config.logging.ledger_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (node.network_params.work.difficulty (*block)))); - } break; } } - - node.stats.inc (nano::stat::type::blockprocessor, nano::to_stat_detail (result.code)); - return result; } diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 5e87663897..fc6c7172a0 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 4656ad5f4f..0502c943ae 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -20,7 +20,8 @@ nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr const & id = nano::hardened_constants::get ().random_128.to_string (); } - node_a->logger.always_log (boost::str (boost::format ("Starting %1% bootstrap attempt with ID %2%") % mode_text () % id)); + node_a->nlogger.debug (nano::log::type::bootstrap, "Starting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); + node_a->bootstrap_initiator.notify_listeners (true); if (node_a->websocket.server) { @@ -36,7 +37,9 @@ nano::bootstrap_attempt::~bootstrap_attempt () { return; } - node->logger.always_log (boost::str (boost::format ("Exiting %1% bootstrap attempt with ID %2%") % mode_text () % id)); + + node->nlogger.debug (nano::log::type::bootstrap, "Exiting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); + node->bootstrap_initiator.notify_listeners (false); if (node->websocket.server) { diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 5c0daa4602..19538bbcd6 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -46,10 +46,8 @@ nano::bulk_pull_client::~bulk_pull_client () } pull.processed += pull_blocks - unexpected_count; node->bootstrap_initiator.connections->requeue_pull (pull, network_error); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Bulk pull end block is not expected %1% for account %2% or head block %3%") % pull.end.to_string () % pull.account_or_head.to_account () % pull.account_or_head.to_string ())); - } + + node->nlogger.debug (nano::log::type::bulk_pull_client, "Bulk pull end block is not expected {} for account {} or head block {}", pull.end.to_string (), pull.account_or_head.to_account (), pull.account_or_head.to_string ()); } else { @@ -82,14 +80,11 @@ void nano::bulk_pull_client::request () req.count = pull.count; req.set_count_present (pull.count != 0); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Requesting account %1% or head block %2% from %3%. %4% accounts in queue") % pull.account_or_head.to_account () % pull.account_or_head.to_string () % connection->channel->to_string () % attempt->pulling)); - } - else if (node->config.logging.network_logging () && attempt->should_log ()) + if (attempt->should_log ()) { - node->logger.always_log (boost::str (boost::format ("%1% accounts in pull queue") % attempt->pulling)); + node->nlogger.debug (nano::log::type::bulk_pull_client, "Accounts in pull queue: {}", attempt->pulling.load ()); } + auto this_l (shared_from_this ()); connection->channel->send ( req, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { @@ -104,10 +99,7 @@ void nano::bulk_pull_client::request () } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error sending bulk pull request to %1%: to %2%") % ec.message () % this_l->connection->channel->to_string ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_client, "Error sending bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_request_failure, nano::stat::dir::in); } }, @@ -168,20 +160,12 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: } if (node->network_params.work.validate_entry (*block)) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Insufficient work for bulk pull block: %1%") % block->hash ().to_string ())); - } - node->stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::insufficient_work); + node->nlogger.debug (nano::log::type::bulk_pull_client, "Insufficient work for bulk pull block: {}", block->hash ().to_string ()); + node->stats.inc (nano::stat::type::error, nano::stat::detail::insufficient_work); return; } auto hash = block->hash (); - if (node->config.logging.bulk_pull_logging ()) - { - std::string block_l; - block->serialize_json (block_l, node->config.logging.single_line_record ()); - node->logger.try_log (boost::str (boost::format ("Pulled block %1% %2%") % hash.to_string () % block_l)); - } + // Is block expected? bool block_expected (false); // Unconfirmed head is used only for lazy destinations if legacy bootstrap is not available, see nano::bootstrap_attempt::lazy_destinations_increment (...) @@ -247,14 +231,12 @@ void nano::bulk_pull_account_client::request () req.account = account; req.minimum_amount = node->config.receive_minimum; req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount; - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Requesting pending for account %1% from %2%. %3% accounts in queue") % req.account.to_account () % connection->channel->to_string () % attempt->wallet_size ())); - } - else if (node->config.logging.network_logging () && attempt->should_log ()) + + if (attempt->should_log ()) { - node->logger.always_log (boost::str (boost::format ("%1% accounts in pull queue") % attempt->wallet_size ())); + node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Accounts in pull queue: {}", attempt->wallet_size ()); } + auto this_l (shared_from_this ()); connection->channel->send ( req, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { @@ -269,12 +251,10 @@ void nano::bulk_pull_account_client::request () } else { - this_l->attempt->requeue_pending (this_l->account); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error starting bulk pull request to %1%: to %2%") % ec.message () % this_l->connection->channel->to_string ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Error starting bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_error_starting_request, nano::stat::dir::in); + + this_l->attempt->requeue_pending (this_l->account); } }, nano::transport::buffer_drop_policy::no_limiter_drop); @@ -334,20 +314,16 @@ void nano::bulk_pull_account_client::receive_pending () } else { + node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Error while receiving bulk pull account frontier: {}", ec.message ()); + this_l->attempt->requeue_pending (this_l->account); - if (node->config.logging.network_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error while receiving bulk pull account frontier %1%") % ec.message ())); - } } } else { + node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Invalid size: Expected {}, got: {}", size_l, size_a); + this_l->attempt->requeue_pending (this_l->account); - if (node->config.logging.network_message_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Invalid size: expected %1%, got %2%") % size_l % size_a)); - } } }); } @@ -379,19 +355,14 @@ void nano::bulk_pull_server::set_current_end () auto transaction (node->store.tx_begin_read ()); if (!node->store.block.exists (transaction, request->end)) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Bulk pull end block doesn't exist: %1%, sending everything") % request->end.to_string ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk pull end block doesn't exist: {}, sending everything", request->end.to_string ()); + request->end.clear (); } if (node->store.block.exists (transaction, request->start.as_block_hash ())) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Bulk pull request for block hash: %1%") % request->start.to_string ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk pull request for block hash: {}", request->start.to_string ()); current = ascending () ? node->store.block.successor (transaction, request->start.as_block_hash ()) : request->start.as_block_hash (); include_start = true; @@ -401,10 +372,8 @@ void nano::bulk_pull_server::set_current_end () auto info = node->ledger.account_info (transaction, request->start.as_account ()); if (!info) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Request for unknown account: %1%") % request->start.to_account ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Request for unknown account: {}", request->start.to_account ()); + current = request->end; } else @@ -415,10 +384,8 @@ void nano::bulk_pull_server::set_current_end () auto account (node->ledger.account (transaction, request->end)); if (account != request->start.as_account ()) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Request for block that is not on account chain: %1% not on %2%") % request->end.to_string () % request->start.to_account ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Request for block that is not on account chain: {} not on {}", request->end.to_string (), request->start.to_account ()); + current = request->end; } } @@ -451,10 +418,7 @@ void nano::bulk_pull_server::send_next () nano::vectorstream stream (send_buffer); nano::serialize_block (stream, *block); } - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block->hash ().to_string ())); - } + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); }); @@ -556,10 +520,7 @@ void nano::bulk_pull_server::sent_action (boost::system::error_code const & ec, } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Unable to bulk send block: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send block: {}", ec.message ()); } } @@ -572,10 +533,9 @@ void nano::bulk_pull_server::send_finished () } nano::shared_const_buffer send_buffer (static_cast (nano::block_type::not_a_block)); auto this_l (shared_from_this ()); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Bulk sending finished"); - } + + node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk sending finished"); + connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->no_block_sent (ec, size_a); }); @@ -595,10 +555,7 @@ void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Unable to send not-a-block"); - } + node->nlogger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send not-a-block: {}", ec.message ()); } } @@ -650,13 +607,9 @@ void nano::bulk_pull_account_server::set_params () } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Invalid bulk_pull_account flags supplied %1%") % static_cast (request->flags))); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Invalid bulk_pull_account flags supplied: {}", static_cast (request->flags)); invalid_request = true; - return; } @@ -729,23 +682,11 @@ void nano::bulk_pull_account_server::send_next_block () if (pending_address_only) { nano::vectorstream output_stream (send_buffer); - - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Sending address: %1%") % block_info->source.to_string ())); - } - write (output_stream, block_info->source.bytes); } else { nano::vectorstream output_stream (send_buffer); - - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block_info_key->hash.to_string ())); - } - write (output_stream, block_info_key->hash.bytes); write (output_stream, block_info->amount.bytes); @@ -768,10 +709,7 @@ void nano::bulk_pull_account_server::send_next_block () /* * Otherwise, finalize the connection */ - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Done sending blocks"))); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Done sending blocks"); send_finished (); } @@ -876,10 +814,7 @@ void nano::bulk_pull_account_server::sent_action (boost::system::error_code cons } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Unable to bulk send block: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Unable to bulk send block: {}", ec.message ()); } } @@ -916,13 +851,9 @@ void nano::bulk_pull_account_server::send_finished () } } - auto this_l (shared_from_this ()); - - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Bulk sending for an account finished"); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Bulk sending for an account finished"); + auto this_l (shared_from_this ()); connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->complete (ec, size_a); }); @@ -957,10 +888,7 @@ void nano::bulk_pull_account_server::complete (boost::system::error_code const & } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Unable to pending-as-zero"); - } + node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Unable to pending-as-zero: {}", ec.message ()); } } diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index dd1fc76f3c..8dfeeeeb9a 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -38,10 +38,7 @@ void nano::bulk_push_client::start () } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Unable to send bulk_push request: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::bulk_push_client, "Unable to send bulk push request: {}", ec.message ()); } }, nano::transport::buffer_drop_policy::no_limiter_drop); @@ -71,10 +68,7 @@ void nano::bulk_push_client::push () } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Bulk pushing range ", current_target.first.to_string (), " down to ", current_target.second.to_string ()); - } + node->nlogger.debug (nano::log::type::bulk_push_client, "Bulk pushing range: [{}:{}]", current_target.first.to_string (), current_target.second.to_string ()); } } } @@ -124,10 +118,7 @@ void nano::bulk_push_client::push_block (nano::block const & block_a) } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error sending block during bulk push: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::bulk_push_client, "Error sending block during bulk push: {}", ec.message ()); } }); } @@ -171,10 +162,7 @@ void nano::bulk_push_server::receive () } if (node->bootstrap_initiator.in_progress ()) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Aborting bulk_push because a bootstrap attempt is in progress"); - } + node->nlogger.debug (nano::log::type::bulk_push_server, "Aborting bulk push because a bootstrap attempt is in progress"); } else { @@ -191,10 +179,7 @@ void nano::bulk_push_server::receive () } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error receiving block type: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::bulk_push_server, "Error receiving block type: {}", ec.message ()); } }); } @@ -258,10 +243,7 @@ void nano::bulk_push_server::received_type () } default: { - if (node->config.logging.network_packet_logging ()) - { - node->logger.try_log ("Unknown type received as block type"); - } + node->nlogger.debug (nano::log::type::bulk_push_server, "Unknown type received as block type"); break; } } @@ -282,11 +264,8 @@ void nano::bulk_push_server::received_block (boost::system::error_code const & e { if (node->network_params.work.validate_entry (*block)) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Insufficient work for bulk push block: %1%") % block->hash ().to_string ())); - } - node->stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::insufficient_work); + node->nlogger.debug (nano::log::type::bulk_push_server, "Insufficient work for bulk push block: {}", block->hash ().to_string ()); + node->stats.inc (nano::stat::type::error, nano::stat::detail::insufficient_work); return; } node->process_active (std::move (block)); @@ -294,10 +273,7 @@ void nano::bulk_push_server::received_block (boost::system::error_code const & e } else { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Error deserializing block received from pull request"); - } + node->nlogger.debug (nano::log::type::bulk_push_server, "Error deserializing block received from pull request"); } } } diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index 6287add5a3..cb5947a320 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -91,7 +91,8 @@ std::shared_ptr nano::bootstrap_connections::connection } if (result == nullptr && connections_count == 0 && new_connections_empty && attempt_a != nullptr) { - node.logger.try_log (boost::str (boost::format ("Bootstrap attempt stopped because there are no peers"))); + node.nlogger.debug (nano::log::type::bootstrap, "Bootstrap attempt stopped because there are no peers"); + lock.unlock (); attempt_a->stop (); } @@ -157,10 +158,8 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) { if (!ec) { - if (this_l->node.config.logging.bulk_pull_logging ()) - { - this_l->node.logger.try_log (boost::str (boost::format ("Connection established to %1%") % endpoint_a)); - } + this_l->node.nlogger.debug (nano::log::type::bootstrap, "Connection established to: {}", nano::util::to_str (endpoint_a)); + auto client (std::make_shared (this_l->node.shared (), std::make_shared (*this_l->node.shared (), socket), socket)); this_l->pool_connection (client, true, push_front); } @@ -171,7 +170,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end switch (ec.value ()) { default: - this_l->node.logger.try_log (boost::str (boost::format ("Error initiating bootstrap connection to %1%: %2%") % endpoint_a % ec.message ())); + this_l->node.nlogger.debug (nano::log::type::bootstrap, "Error initiating bootstrap connection to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); break; case boost::system::errc::connection_refused: case boost::system::errc::operation_canceled: @@ -236,10 +235,12 @@ void nano::bootstrap_connections::populate_connections (bool repeat) // This is ~1.5kilobits/sec. if (elapsed_sec > nano::bootstrap_limits::bootstrap_minimum_termination_time_sec && blocks_per_sec < nano::bootstrap_limits::bootstrap_minimum_blocks_per_sec) { - if (node.config.logging.bulk_pull_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Stopping slow peer %1% (elapsed sec %2%s > %3%s and %4% blocks per second < %5%)") % client->channel->to_string () % elapsed_sec % nano::bootstrap_limits::bootstrap_minimum_termination_time_sec % blocks_per_sec % nano::bootstrap_limits::bootstrap_minimum_blocks_per_sec)); - } + node.nlogger.debug (nano::log::type::bootstrap, "Stopping slow peer {} (elapsed sec {} > {} and {} blocks per second < {})", + client->channel->to_string (), + elapsed_sec, + nano::bootstrap_limits::bootstrap_minimum_termination_time_sec, + blocks_per_sec, + nano::bootstrap_limits::bootstrap_minimum_blocks_per_sec); client->stop (true); new_clients.pop_back (); @@ -259,29 +260,27 @@ void nano::bootstrap_connections::populate_connections (bool repeat) // 4 -> 1, 8 -> 2, 16 -> 4, arbitrary, but seems to work well. auto drop = (int)roundf (sqrtf ((float)target - 2.0f)); - if (node.config.logging.bulk_pull_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Dropping %1% bulk pull peers, target connections %2%") % drop % target)); - } + node.nlogger.debug (nano::log::type::bootstrap, "Dropping {} bulk pull peers, target connections {}", drop, target); for (int i = 0; i < drop; i++) { auto client = sorted_connections.top (); - if (node.config.logging.bulk_pull_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Dropping peer with block rate %1%, block count %2% (%3%) ") % client->block_rate % client->block_count % client->channel->to_string ())); - } + node.nlogger.debug (nano::log::type::bootstrap, "Dropping peer with block rate {} and block count {} ({})", + client->block_rate.load (), + client->block_count.load (), + client->channel->to_string ()); client->stop (false); sorted_connections.pop (); } } - if (node.config.logging.bulk_pull_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Bulk pull connections: %1%, rate: %2% blocks/sec, bootstrap attempts %3%, remaining pulls: %4%") % connections_count.load () % (int)rate_sum % attempts_count % num_pulls)); - } + node.nlogger.debug (nano::log::type::bootstrap, "Bulk pull connections: {}, rate: {} blocks/sec, bootstrap attempts {}, remaining pulls: {}", + connections_count.load (), + (int)rate_sum, + attempts_count, + num_pulls); if (connections_count < target && (attempts_count != 0 || new_connections_empty) && !stopped) { @@ -423,11 +422,13 @@ void nano::bootstrap_connections::requeue_pull (nano::pull_info const & pull_a, } else { - if (node.config.logging.bulk_pull_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Failed to pull account %1% or head block %2% down to %3% after %4% attempts and %5% blocks processed") % pull.account_or_head.to_account () % pull.account_or_head.to_string () % pull.end.to_string () % pull.attempts % pull.processed)); - } node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in); + node.nlogger.debug (nano::log::type::bootstrap, "Failed to pull account {} or head block {} down to {} after {} attempts and {} blocks processed", + pull.account_or_head.to_account (), + pull.account_or_head.to_string (), + pull.end.to_string (), + pull.attempts, + pull.processed); if (lazy && pull.processed > 0) { diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 6b8766fc24..b438c8a22d 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -42,10 +42,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint } else { - if (node->config.logging.network_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error while sending bootstrap request %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::frontier_req_client, "Error while sending bootstrap request: {}", ec.message ()); } }, nano::transport::buffer_drop_policy::no_limiter_drop); @@ -76,10 +73,7 @@ void nano::frontier_req_client::receive_frontier () } else { - if (node->config.logging.network_message_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Invalid size: expected %1%, got %2%") % nano::frontier_req_client::size_frontier % size_a)); - } + node->nlogger.debug (nano::log::type::frontier_req_client, "Invalid size: expected {}, got {}", nano::frontier_req_client::size_frontier, size_a); } }); } @@ -137,14 +131,17 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con double age_factor = (frontiers_age == std::numeric_limits::max ()) ? 1.0 : 1.5; // Allow slower frontiers receive for requests with age if (elapsed_sec > nano::bootstrap_limits::bootstrap_connection_warmup_time_sec && blocks_per_sec * age_factor < nano::bootstrap_limits::bootstrap_minimum_frontier_blocks_per_sec) { - node->logger.try_log (boost::str (boost::format ("Aborting frontier req because it was too slow: %1% frontiers per second, last %2%") % blocks_per_sec % account.to_account ())); + node->nlogger.debug (nano::log::type::frontier_req_client, "Aborting frontier req because it was too slow: {} frontiers per second, last {}", blocks_per_sec, account.to_account ()); + promise.set_value (true); return; } + if (attempt->should_log ()) { - node->logger.always_log (boost::str (boost::format ("Received %1% frontiers from %2%") % std::to_string (count) % connection->channel->to_string ())); + node->nlogger.debug (nano::log::type::frontier_req_client, "Received {} frontiers from {}", count, connection->channel->to_string ()); } + if (!account.is_zero () && count <= count_limit) { last_account = account; @@ -203,10 +200,8 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con } // Prevent new frontier_req requests attempt->set_start_account (std::numeric_limits::max ()); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Bulk push cost: ", bulk_push_cost); - } + + node->nlogger.debug (nano::log::type::frontier_req_client, "Bulk push cost: {}", bulk_push_cost); } else { @@ -225,10 +220,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con } else { - if (node->config.logging.network_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error while receiving frontier %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::frontier_req_client, "Error while receiving frontier: {}", ec.message ()); } } @@ -291,11 +283,8 @@ void nano::frontier_req_server::send_next () debug_assert (!current.is_zero ()); debug_assert (!frontier.is_zero ()); } + auto this_l (shared_from_this ()); - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Sending frontier for %1% %2%") % current.to_account () % frontier.to_string ())); - } next (); connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); @@ -321,11 +310,10 @@ void nano::frontier_req_server::send_finished () write (stream, zero.bytes); write (stream, zero.bytes); } + + node->nlogger.debug (nano::log::type::frontier_req_server, "Frontier sending finished"); + auto this_l (shared_from_this ()); - if (node->config.logging.network_logging ()) - { - node->logger.try_log ("Frontier sending finished"); - } connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->no_block_sent (ec, size_a); }); @@ -344,10 +332,7 @@ void nano::frontier_req_server::no_block_sent (boost::system::error_code const & } else { - if (node->config.logging.network_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error sending frontier finish: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::frontier_req_server, "Error sending frontier finish: {}", ec.message ()); } } @@ -368,10 +353,7 @@ void nano::frontier_req_server::sent_action (boost::system::error_code const & e } else { - if (node->config.logging.network_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error sending frontier pair: %1%") % ec.message ())); - } + node->nlogger.debug (nano::log::type::frontier_req_server, "Error sending frontier pair: {}", ec.message ()); } } diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 28e5cf6ad0..35b0153120 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -250,11 +250,11 @@ void nano::bootstrap_attempt_lazy::run () } if (!stopped) { - node->logger.try_log ("Completed lazy pulls"); + node->nlogger.debug (nano::log::type::bootstrap_lazy, "Completed lazy pulls"); } if (lazy_has_expired ()) { - node->logger.try_log (boost::str (boost::format ("Lazy bootstrap attempt ID %1% expired") % id)); + node->nlogger.debug (nano::log::type::bootstrap_lazy, "Lazy bootstrap attempt ID {} expired", id); } lock.unlock (); stop (); @@ -613,7 +613,7 @@ void nano::bootstrap_attempt_wallet::run () } if (!stopped) { - node->logger.try_log ("Completed wallet lazy pulls"); + node->nlogger.info (nano::log::type::bootstrap_lazy, "Completed wallet lazy pulls"); } lock.unlock (); stop (); diff --git a/nano/node/bootstrap/bootstrap_legacy.cpp b/nano/node/bootstrap/bootstrap_legacy.cpp index 481d6df85b..2a1c670979 100644 --- a/nano/node/bootstrap/bootstrap_legacy.cpp +++ b/nano/node/bootstrap/bootstrap_legacy.cpp @@ -88,14 +88,6 @@ void nano::bootstrap_attempt_legacy::request_push (nano::unique_lockconfig.logging.network_logging ()) - { - node->logger.try_log ("Exiting bulk push client"); - if (error) - { - node->logger.try_log ("Bulk push client failed"); - } - } } void nano::bootstrap_attempt_legacy::add_frontier (nano::pull_info const & pull_a) @@ -186,16 +178,13 @@ bool nano::bootstrap_attempt_legacy::request_frontier (nano::unique_lockconfig.logging.network_logging ()) + if (!result) { - if (!result) - { - node->logger.try_log (boost::str (boost::format ("Completed frontier request, %1% out of sync accounts according to %2%") % account_count % connection_l->channel->to_string ())); - } - else - { - node->stats.inc (nano::stat::type::error, nano::stat::detail::frontier_req, nano::stat::dir::out); - } + node->nlogger.debug (nano::log::type::bootstrap_legacy, "Completed frontier request, {} out of sync accounts according to {}", account_count.load (), connection_l->channel->to_string ()); + } + else + { + node->stats.inc (nano::stat::type::error, nano::stat::detail::frontier_req, nano::stat::dir::out); } } return result; @@ -233,25 +222,24 @@ void nano::bootstrap_attempt_legacy::run () // clang-format off condition.wait (lock, [&stopped = stopped, &pulling = pulling] { return stopped || pulling == 0; }); } + // Flushing may resolve forks which can add more pulls - node->logger.try_log ("Flushing unchecked blocks"); lock.unlock (); node->block_processor.flush (); lock.lock (); + if (start_account.number () != std::numeric_limits::max ()) { - node->logger.try_log (boost::str (boost::format ("Finished flushing unchecked blocks, requesting new frontiers after %1%") % start_account.to_account ())); + node->nlogger.debug(nano::log::type::bootstrap_legacy, "Requesting new frontiers after: {}", start_account.to_account ()); + // Requesting new frontiers run_start (lock); } - else - { - node->logger.try_log ("Finished flushing unchecked blocks"); - } } if (!stopped) { - node->logger.try_log ("Completed legacy pulls"); + node->nlogger.debug(nano::log::type::bootstrap_legacy, "Completed legacy pulls"); + if (!node->flags.disable_bootstrap_bulk_push_client) { request_push (lock); diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 721edd67ff..9ec0539b4c 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -730,7 +730,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map environment.dump (std::cout); std::stringstream stream; environment.dump (stream); - inactive_node->node->logger.always_log (stream.str ()); + std::cout << stream.str () << std::endl; } else { diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index a2301f891d..44569ebbe4 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -12,12 +12,11 @@ #include -nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : +nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::nlogger & nlogger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a), - logging (logging_a), - logger (logger_a), + nlogger (nlogger_a), stopped (stopped_a), batch_write_size (batch_write_size_a), notify_observers_callback (notify_observers_callback_a), @@ -101,9 +100,8 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or } else { - auto error_str = (boost::format ("Ledger mismatch trying to set confirmation height for block %1% (bounded processor)") % current.to_string ()).str (); - logger.always_log (error_str); - std::cerr << error_str << std::endl; + nlogger.critical (nano::log::type::conf_processor_bounded, "Ledger mismatch trying to set confirmation height for block {} (bounded processor)", current.to_string ()); + release_assert (block); } } @@ -433,9 +431,8 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope { if (!block) { - auto error_str = (boost::format ("Failed to write confirmation height for block %1% (bounded processor)") % new_cemented_frontier.to_string ()).str (); - logger.always_log (error_str); - std::cerr << error_str << std::endl; + nlogger.critical (nano::log::type::conf_processor_bounded, "Failed to write confirmation height for block {} (bounded processor)", new_cemented_frontier.to_string ()); + // Undo any blocks about to be cemented from this account for this pending write. cemented_blocks.erase (cemented_blocks.end () - num_blocks_iterated, cemented_blocks.end ()); error = true; @@ -455,10 +452,6 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope total_blocks_cemented += num_blocks_cemented; write_confirmation_height (num_blocks_cemented, start_height + total_blocks_cemented - 1, new_cemented_frontier); transaction.commit (); - if (logging.timing_logging ()) - { - logger.always_log (boost::str (boost::format ("Cemented %1% blocks in %2% %3% (bounded processor)") % cemented_blocks.size () % time_spent_cementing % cemented_batch_timer.unit ())); - } // Update the maximum amount of blocks to write next time based on the time it took to cement this batch. if (time_spent_cementing > maximum_batch_write_time) @@ -521,11 +514,8 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope --pending_writes_size; } } - auto time_spent_cementing = cemented_batch_timer.since_start ().count (); - if (logging.timing_logging () && time_spent_cementing > 50) - { - logger.always_log (boost::str (boost::format ("Cemented %1% blocks in %2% %3% (bounded processor)") % cemented_blocks.size () % time_spent_cementing % cemented_batch_timer.unit ())); - } + + auto time_spent_cementing = cemented_batch_timer.since_start (); // Scope guard could have been released earlier (0 cemented_blocks would indicate that) if (scoped_write_guard_a.is_owned () && !cemented_blocks.empty ()) @@ -537,7 +527,8 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope // Bail if there was an error. This indicates that there was a fatal issue with the ledger // (the blocks probably got rolled back when they shouldn't have). release_assert (!error); - if (time_spent_cementing > maximum_batch_write_time) + + if (time_spent_cementing.count () > maximum_batch_write_time) { // Reduce (unless we have hit a floor) batch_write_size = std::max (minimum_batch_write_size, batch_write_size - amount_to_change); diff --git a/nano/node/confirmation_height_bounded.hpp b/nano/node/confirmation_height_bounded.hpp index c176b41686..c42cd61397 100644 --- a/nano/node/confirmation_height_bounded.hpp +++ b/nano/node/confirmation_height_bounded.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -19,7 +20,8 @@ class write_guard; class confirmation_height_bounded final { public: - confirmation_height_bounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::logging const &, nano::logger_mt &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + confirmation_height_bounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::nlogger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + bool pending_empty () const; void clear_process_vars (); void process (std::shared_ptr original_block); @@ -121,8 +123,7 @@ class confirmation_height_bounded final nano::ledger & ledger; nano::write_database_queue & write_database_queue; std::chrono::milliseconds batch_separate_pending_min_time; - nano::logging const & logging; - nano::logger_mt & logger; + nano::nlogger & nlogger; std::atomic & stopped; uint64_t & batch_write_size; std::function> const &)> notify_observers_callback; diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index 6cf9772999..6e937c54c1 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -9,16 +9,16 @@ #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::logging const & logging_a, nano::logger_mt & logger_a, boost::latch & latch, confirmation_height_mode mode_a) : +nano::confirmation_height_processor::confirmation_height_processor (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::nlogger & nlogger_a, boost::latch & latch, confirmation_height_mode mode_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), unbounded_processor ( - ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, + ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, nlogger_a, stopped, batch_write_size, /* cemented_callback */ [this] (auto & cemented_blocks) { this->notify_cemented (cemented_blocks); }, /* already cemented_callback */ [this] (auto const & block_hash_a) { this->notify_already_cemented (block_hash_a); }, /* awaiting_processing_size_query */ [this] () { return this->awaiting_processing_size (); }), bounded_processor ( - ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, + ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, nlogger_a, stopped, batch_write_size, /* cemented_callback */ [this] (auto & cemented_blocks) { this->notify_cemented (cemented_blocks); }, /* already cemented_callback */ [this] (auto const & block_hash_a) { this->notify_already_cemented (block_hash_a); }, /* awaiting_processing_size_query */ [this] () { return this->awaiting_processing_size (); }), diff --git a/nano/node/confirmation_height_processor.hpp b/nano/node/confirmation_height_processor.hpp index 88f2d1a15b..1767f82106 100644 --- a/nano/node/confirmation_height_processor.hpp +++ b/nano/node/confirmation_height_processor.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -24,14 +25,14 @@ class latch; namespace nano { class ledger; -class logger_mt; class write_database_queue; class confirmation_height_processor final { public: - confirmation_height_processor (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds, nano::logging const &, nano::logger_mt &, boost::latch & initialized_latch, confirmation_height_mode = confirmation_height_mode::automatic); + confirmation_height_processor (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds, nano::nlogger &, boost::latch & initialized_latch, confirmation_height_mode = confirmation_height_mode::automatic); ~confirmation_height_processor (); + void pause (); void unpause (); void stop (); diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 9a458b9c8c..c7edd9cdbc 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -12,12 +12,11 @@ #include -nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : +nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::nlogger & nlogger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a), - logging (logging_a), - logger (logger_a), + nlogger (nlogger_a), stopped (stopped_a), batch_write_size (batch_write_size_a), notify_observers_callback (notify_observers_callback_a), @@ -77,9 +76,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr } if (!block) { - auto error_str = (boost::format ("Ledger mismatch trying to set confirmation height for block %1% (unbounded processor)") % current.to_string ()).str (); - logger.always_log (error_str); - std::cerr << error_str << std::endl; + nlogger.critical (nano::log::type::conf_processor_unbounded, "Ledger mismatch trying to set confirmation height for block {} (unbounded processor)", current.to_string ()); } release_assert (block); @@ -395,9 +392,8 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco } else { - auto error_str = (boost::format ("Failed to write confirmation height for block %1% (unbounded processor)") % pending.hash.to_string ()).str (); - logger.always_log (error_str); - std::cerr << error_str << std::endl; + nlogger.critical (nano::log::type::conf_processor_unbounded, "Failed to write confirmation height for block {} (unbounded processor)", pending.hash.to_string ()); + error = true; break; } @@ -424,10 +420,6 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco } auto time_spent_cementing = cemented_batch_timer.since_start ().count (); - if (logging.timing_logging () && time_spent_cementing > 50) - { - logger.always_log (boost::str (boost::format ("Cemented %1% blocks in %2% %3% (unbounded processor)") % cemented_blocks.size () % time_spent_cementing % cemented_batch_timer.unit ())); - } scoped_write_guard_a.release (); notify_observers_callback (cemented_blocks); diff --git a/nano/node/confirmation_height_unbounded.hpp b/nano/node/confirmation_height_unbounded.hpp index 0af353e69a..9bee338c4d 100644 --- a/nano/node/confirmation_height_unbounded.hpp +++ b/nano/node/confirmation_height_unbounded.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -20,7 +21,8 @@ class write_guard; class confirmation_height_unbounded final { public: - confirmation_height_unbounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::logging const &, nano::logger_mt &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + confirmation_height_unbounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::nlogger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + bool pending_empty () const; void clear_process_vars (); void process (std::shared_ptr original_block); @@ -98,10 +100,9 @@ class confirmation_height_unbounded final nano::ledger & ledger; nano::write_database_queue & write_database_queue; std::chrono::milliseconds batch_separate_pending_min_time; - nano::logger_mt & logger; + nano::nlogger & nlogger; std::atomic & stopped; uint64_t & batch_write_size; - nano::logging const & logging; std::function> const &)> notify_observers_callback; std::function notify_block_already_cemented_observers_callback; diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index b710c41552..d7031f5f18 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -94,7 +94,8 @@ void nano::distributed_work::start () } else { - this_l->node.logger.try_log (boost::str (boost::format ("Error resolving work peer: %1%:%2%: %3%") % peer.first % peer.second % ec.message ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Error resolving work peer: {}:{} ({})", peer.first, peer.second, ec.message ()); + this_l->failure (); } }); @@ -166,7 +167,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec) { - this_l->node.logger.try_log (boost::str (boost::format ("Work peer responded with an error %1% %2%: %3%") % connection->endpoint.address () % connection->endpoint.port () % connection->response.result ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Work peer responded with an error {}:{} ({})", + nano::util::to_str (connection->endpoint.address ()), + connection->endpoint.port (), + ec.message ()); + this_l->add_bad_peer (connection->endpoint); this_l->failure (); } @@ -180,7 +185,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.logger.try_log (boost::str (boost::format ("Unable to write to work_peer %1% %2%: %3% (%4%)") % connection->endpoint.address () % connection->endpoint.port () % ec.message () % ec.value ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to write to work peer {}:{} ({})", + nano::util::to_str (connection->endpoint.address ()), + connection->endpoint.port (), + ec.message ()); + this_l->add_bad_peer (connection->endpoint); this_l->failure (); } @@ -188,7 +197,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.logger.try_log (boost::str (boost::format ("Unable to connect to work_peer %1% %2%: %3% (%4%)") % connection->endpoint.address () % connection->endpoint.port () % ec.message () % ec.value ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to connect to work peer {}:{} ({})", + nano::util::to_str (connection->endpoint.address ()), + connection->endpoint.port (), + ec.message ()); + this_l->add_bad_peer (connection->endpoint); this_l->failure (); } @@ -219,7 +232,10 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a) [this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, std::size_t bytes_transferred) { if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.logger.try_log (boost::str (boost::format ("Unable to send work_cancel to work_peer %1% %2%: %3% (%4%)") % cancelling_l->endpoint.address () % cancelling_l->endpoint.port () % ec.message () % ec.value ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to send work cancel to work peer {}:{} ({})", + nano::util::to_str (cancelling_l->endpoint.address ()), + cancelling_l->endpoint.port (), + ec.message ()); } })); } @@ -247,17 +263,28 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp } else { - node.logger.try_log (boost::str (boost::format ("Incorrect work response from %1%:%2% for root %3% with diffuculty %4%: %5%") % endpoint_a.address () % endpoint_a.port () % request.root.to_string () % nano::to_string_hex (request.difficulty) % work_text)); + node.nlogger.error (nano::log::type::distributed_work, "Incorrect work response from {}:{} for root {} with diffuculty {}: {}", + nano::util::to_str (endpoint_a.address ()), + endpoint_a.port (), + request.root.to_string (), + nano::to_string_hex (request.difficulty), + work_text); } } else { - node.logger.try_log (boost::str (boost::format ("Work response from %1%:%2% wasn't a number: %3%") % endpoint_a.address () % endpoint_a.port () % work_text)); + node.nlogger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't a number: {}", + nano::util::to_str (endpoint_a.address ()), + endpoint_a.port (), + work_text); } } catch (...) { - node.logger.try_log (boost::str (boost::format ("Work response from %1%:%2% wasn't parsable: %3%") % endpoint_a.address () % endpoint_a.port () % body_a)); + node.nlogger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't parsable: {}", + nano::util::to_str (endpoint_a.address ()), + endpoint_a.port (), + body_a); } if (error) { @@ -290,12 +317,18 @@ void nano::distributed_work::stop_once (bool const local_stop_a) connection_l->socket.close (ec); if (ec) { - this_l->node.logger.try_log (boost::str (boost::format ("Error closing socket with work_peer %1% %2%: %3%") % connection_l->endpoint.address () % connection_l->endpoint.port () % ec.message () % ec.value ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Error closing socket with work peer: {}:{} ({})", + nano::util::to_str (connection_l->endpoint.address ()), + connection_l->endpoint.port (), + ec.message ()); } } else { - this_l->node.logger.try_log (boost::str (boost::format ("Error cancelling operation with work_peer %1% %2%: %3%") % connection_l->endpoint.address () % connection_l->endpoint.port () % ec.message () % ec.value ())); + this_l->node.nlogger.error (nano::log::type::distributed_work, "Error cancelling operation with work peer: {}:{} ({})", + nano::util::to_str (connection_l->endpoint.address ()), + connection_l->endpoint.port (), + ec.message ()); } } })); @@ -310,6 +343,13 @@ void nano::distributed_work::set_once (uint64_t const work_a, std::string const if (!finished.exchange (true)) { elapsed.stop (); + + node.nlogger.info (nano::log::type::distributed_work, "Work generation for {}, with a threshold difficulty of {} (multiplier {}x) complete: {} ms", + request.root.to_string (), + nano::to_string_hex (request.difficulty), + nano::to_string (nano::difficulty::to_multiplier (request.difficulty, node.default_difficulty (request.version)), 2), + elapsed.value ().count ()); + status = work_generation_status::success; if (request.callback) { @@ -317,12 +357,6 @@ void nano::distributed_work::set_once (uint64_t const work_a, std::string const } winner = source_a; work_result = work_a; - if (node.config.logging.work_generation_time ()) - { - boost::format unformatted_l ("Work generation for %1%, with a threshold difficulty of %2% (multiplier %3%x) complete: %4% ms"); - auto multiplier_text_l (nano::to_string (nano::difficulty::to_multiplier (request.difficulty, node.default_difficulty (request.version)), 2)); - node.logger.try_log (boost::str (unformatted_l % request.root.to_string () % nano::to_string_hex (request.difficulty) % multiplier_text_l % elapsed.value ().count ())); - } } } @@ -331,16 +365,17 @@ void nano::distributed_work::cancel () if (!finished.exchange (true)) { elapsed.stop (); + + node.nlogger.info (nano::log::type::distributed_work, "Work generation for {} was cancelled after {} ms", + request.root.to_string (), + elapsed.value ().count ()); + status = work_generation_status::cancelled; if (request.callback) { request.callback (boost::none); } stop_once (true); - if (node.config.logging.work_generation_time ()) - { - node.logger.try_log (boost::str (boost::format ("Work generation for %1% was cancelled after %2% ms") % request.root.to_string () % elapsed.value ().count ())); - } } } @@ -359,11 +394,12 @@ void nano::distributed_work::handle_failure () node.unresponsive_work_peers = true; if (!local_generation_started && !finished.exchange (true)) { + node.nlogger.info (nano::log::type::distributed_work, "Work peer(s) failed to generate work for root {}, retrying... (backoff: {}s)", + request.root.to_string (), + backoff.count ()); + status = work_generation_status::failure_peers; - if (backoff == std::chrono::seconds (1) && node.config.logging.work_generation_time ()) - { - node.logger.always_log ("Work peer(s) failed to generate work for root ", request.root.to_string (), ", retrying..."); - } + auto now (std::chrono::steady_clock::now ()); std::weak_ptr node_weak (node.shared ()); auto next_backoff (std::min (backoff * 2, std::chrono::seconds (5 * 60))); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 93c681c706..ab4aab345c 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -250,10 +250,6 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a if (!state_change (state_m, nano::election::state_t::expired_unconfirmed)) { result = true; // Return true to indicate this election should be cleaned up - if (node.config.logging.election_expiration_tally_logging ()) - { - log_votes (tally_impl (), "Election expired: "); - } status.type = nano::election_status_type::stopped; } } @@ -375,10 +371,6 @@ void nano::election::confirm_if_quorum (nano::unique_lock & lock_a) } if (!node.ledger.cache.final_votes_confirmation_canary.load () || final_weight >= node.online_reps.delta ()) { - if (node.config.logging.vote_logging () || (node.config.logging.election_fork_tally_logging () && last_blocks.size () > 1)) - { - log_votes (tally_l); - } confirm_once (lock_a, nano::election_status_type::active_confirmed_quorum); } } @@ -419,25 +411,6 @@ nano::election_status nano::election::set_status_type (nano::election_status_typ return status_l; } -void nano::election::log_votes (nano::tally_t const & tally_a, std::string const & prefix_a) const -{ - std::stringstream tally; - std::string line_end (node.config.logging.single_line_record () ? "\t" : "\n"); - tally << boost::str (boost::format ("%1%%2%Vote tally for root %3%, final weight:%4%") % prefix_a % line_end % root.to_string () % final_weight); - for (auto i (tally_a.begin ()), n (tally_a.end ()); i != n; ++i) - { - tally << boost::str (boost::format ("%1%Block %2% weight %3%") % line_end % i->second->hash ().to_string () % i->first.convert_to ()); - } - for (auto i (last_votes.begin ()), n (last_votes.end ()); i != n; ++i) - { - if (i->first != nullptr) - { - tally << boost::str (boost::format ("%1%%2% %3% %4%") % line_end % i->first.to_account () % std::to_string (i->second.timestamp) % i->second.hash.to_string ()); - } - } - node.logger.try_log (tally.str ()); -} - std::shared_ptr nano::election::find (nano::block_hash const & hash_a) const { std::shared_ptr result; diff --git a/nano/node/election.hpp b/nano/node/election.hpp index b49f946540..8c025f654a 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -62,6 +63,9 @@ enum class election_behavior nano::stat::detail to_stat_detail (nano::election_behavior); +// map of vote weight per block, ordered greater first +using tally_t = std::map, std::greater>; + struct election_extended_status final { nano::election_status status; @@ -120,7 +124,6 @@ class election final : public std::enable_shared_from_this std::shared_ptr winner () const; std::atomic confirmation_request_count{ 0 }; - void log_votes (nano::tally_t const &, std::string const & = "") const; nano::tally_t tally () const; bool have_quorum (nano::tally_t const &) const; diff --git a/nano/node/epoch_upgrader.cpp b/nano/node/epoch_upgrader.cpp index a731bb4da8..c9443cd367 100644 --- a/nano/node/epoch_upgrader.cpp +++ b/nano/node/epoch_upgrader.cpp @@ -2,12 +2,12 @@ #include #include -nano::epoch_upgrader::epoch_upgrader (nano::node & node_a, nano::ledger & ledger_a, nano::store::component & store_a, nano::network_params & network_params_a, nano::logger_mt & logger_a) : +nano::epoch_upgrader::epoch_upgrader (nano::node & node_a, nano::ledger & ledger_a, nano::store::component & store_a, nano::network_params & network_params_a, nano::nlogger & nlogger_a) : node{ node_a }, ledger{ ledger_a }, store{ store_a }, network_params{ network_params_a }, - logger{ logger_a } + nlogger{ nlogger_a } { } @@ -59,7 +59,12 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc else { bool fork (result == nano::process_result::fork); - logger.always_log (boost::str (boost::format ("Failed to upgrade account %1%. Valid signature: %2%. Valid work: %3%. Block processor fork: %4%") % account_a.to_account () % valid_signature % valid_work % fork)); + + nlogger.error (nano::log::type::epoch_upgrader, "Failed to upgrade account {} (valid signature: {}, valid work: {}, fork: {})", + account_a.to_account (), + valid_signature, + valid_work, + fork); } }; @@ -181,12 +186,16 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc if (!accounts_list.empty ()) { - logger.always_log (boost::str (boost::format ("%1% accounts were upgraded to new epoch, %2% remain...") % total_upgraded_accounts % (accounts_list.size () - upgraded_accounts))); + nlogger.info (nano::log::type::epoch_upgrader, "{} accounts were upgraded to new epoch, {} remain...", + total_upgraded_accounts, + accounts_list.size () - upgraded_accounts); + accounts_list.clear (); } else { - logger.always_log (boost::str (boost::format ("%1% total accounts were upgraded to new epoch") % total_upgraded_accounts)); + nlogger.info (nano::log::type::epoch_upgrader, "{} total accounts were upgraded to new epoch", total_upgraded_accounts); + finished_accounts = true; } } @@ -284,11 +293,12 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc // Repeat if some pending accounts were upgraded if (upgraded_pending != 0) { - logger.always_log (boost::str (boost::format ("%1% unopened accounts with pending blocks were upgraded to new epoch...") % total_upgraded_pending)); + nlogger.info (nano::log::type::epoch_upgrader, "{} unopened accounts with pending blocks were upgraded to new epoch...", total_upgraded_pending); } else { - logger.always_log (boost::str (boost::format ("%1% total unopened accounts with pending blocks were upgraded to new epoch") % total_upgraded_pending)); + nlogger.info (nano::log::type::epoch_upgrader, "{} total unopened accounts with pending blocks were upgraded to new epoch", total_upgraded_pending); + finished_pending = true; } } @@ -296,5 +306,5 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc finished_upgrade = (total_upgraded_accounts == 0) && (total_upgraded_pending == 0); } - logger.always_log ("Epoch upgrade is completed"); + nlogger.info (nano::log::type::epoch_upgrader, "Epoch upgrade is completed"); } diff --git a/nano/node/epoch_upgrader.hpp b/nano/node/epoch_upgrader.hpp index ab0499fb14..3f85b9985b 100644 --- a/nano/node/epoch_upgrader.hpp +++ b/nano/node/epoch_upgrader.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include @@ -15,12 +16,11 @@ namespace store class component; } class network_params; -class logger_mt; class epoch_upgrader final { public: - epoch_upgrader (nano::node &, nano::ledger &, nano::store::component &, nano::network_params &, nano::logger_mt &); + epoch_upgrader (nano::node &, nano::ledger &, nano::store::component &, nano::network_params &, nano::nlogger &); bool start (nano::raw_key const & prv, nano::epoch epoch, uint64_t count_limit, uint64_t threads); void stop (); @@ -30,7 +30,7 @@ class epoch_upgrader final nano::ledger & ledger; nano::store::component & store; nano::network_params & network_params; - nano::logger_mt & logger; + nano::nlogger & nlogger; private: void upgrade_impl (nano::raw_key const & prv, nano::epoch epoch, uint64_t count_limit, uint64_t threads); diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp index 0153455810..384f1888b6 100644 --- a/nano/node/gap_cache.cpp +++ b/nano/node/gap_cache.cpp @@ -100,7 +100,7 @@ void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a) { if (!node_l->bootstrap_initiator.in_progress ()) { - node_l->logger.try_log (boost::str (boost::format ("Missing block %1% which has enough votes to warrant lazy bootstrapping it") % hash_a.to_string ())); + node_l->nlogger.debug (nano::log::type::gap_cache, "Block {} has enough votes to warrant lazy bootstrapping it", hash_a.to_string ()); } if (!node_l->flags.disable_lazy_bootstrap) { diff --git a/nano/node/ipc/ipc_broker.cpp b/nano/node/ipc/ipc_broker.cpp index 5176b3b131..cf625ee791 100644 --- a/nano/node/ipc/ipc_broker.cpp +++ b/nano/node/ipc/ipc_broker.cpp @@ -65,17 +65,17 @@ void nano::ipc::broker::start () } catch (nano::error const & err) { - this_l->node.logger.always_log ("IPC: could not broadcast message: ", err.get_message ()); + this_l->node.nlogger.error (nano::log::type::ipc, "Could not broadcast message: {}", err.get_message ()); } }); } template -void subscribe_or_unsubscribe (nano::logger_mt & logger, COLL & subscriber_collection, std::weak_ptr const & subscriber_a, TOPIC_TYPE topic_a) +void subscribe_or_unsubscribe (nano::nlogger & nlogger, COLL & subscriber_collection, std::weak_ptr const & subscriber_a, TOPIC_TYPE topic_a) { // Evict subscribers from dead sessions. Also remove current subscriber if unsubscribing. subscriber_collection.erase (std::remove_if (subscriber_collection.begin (), subscriber_collection.end (), - [&logger = logger, topic_a, subscriber_a] (auto & sub) { + [&nlogger = nlogger, topic_a, subscriber_a] (auto & sub) { bool remove = false; auto subscriber_l = sub.subscriber.lock (); if (subscriber_l) @@ -85,7 +85,7 @@ void subscribe_or_unsubscribe (nano::logger_mt & logger, COLL & subscriber_colle remove = topic_a->unsubscribe && subscriber_l->get_id () == calling_subscriber_l->get_id (); if (remove) { - logger.always_log ("IPC: unsubscription from subscriber #", calling_subscriber_l->get_id ()); + nlogger.info (nano::log::type::ipc, "Subscriber ubsubscribed #{}", calling_subscriber_l->get_id ()); } } } @@ -106,7 +106,7 @@ void subscribe_or_unsubscribe (nano::logger_mt & logger, COLL & subscriber_colle void nano::ipc::broker::subscribe (std::weak_ptr const & subscriber_a, std::shared_ptr const & confirmation_a) { auto subscribers = confirmation_subscribers.lock (); - subscribe_or_unsubscribe (node.logger, subscribers.get (), subscriber_a, confirmation_a); + subscribe_or_unsubscribe (node.nlogger, subscribers.get (), subscriber_a, confirmation_a); } void nano::ipc::broker::broadcast (std::shared_ptr const & confirmation_a) @@ -257,5 +257,5 @@ void nano::ipc::broker::service_stop (std::string const & service_name_a) void nano::ipc::broker::subscribe (std::weak_ptr const & subscriber_a, std::shared_ptr const & service_stop_a) { auto subscribers = service_stop_subscribers.lock (); - subscribe_or_unsubscribe (node.logger, subscribers.get (), subscriber_a, service_stop_a); + subscribe_or_unsubscribe (node.nlogger, subscribers.get (), subscriber_a, service_stop_a); } diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index 9eaf1e7509..2a3e4a0185 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -39,10 +39,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f server (server_a), node (server_a.node), session_id (server_a.id_dispenser.fetch_add (1)), io_ctx (io_ctx_a), strand (io_ctx_a.get_executor ()), socket (io_ctx_a), config_transport (config_transport_a) { - if (node.config.logging.log_ipc ()) - { - node.logger.always_log ("IPC: created session with id: ", session_id.load ()); - } + node.nlogger.debug (nano::log::type::ipc, "Creating session with id: ", session_id.load ()); } ~session () @@ -234,10 +231,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f this_l->timer_cancel (); if (ec == boost::asio::error::broken_pipe || ec == boost::asio::error::connection_aborted || ec == boost::asio::error::connection_reset || ec == boost::asio::error::connection_refused) { - if (this_l->node.config.logging.log_ipc ()) - { - this_l->node.logger.always_log (boost::str (boost::format ("IPC: error reading %1% ") % ec.message ())); - } + this_l->node.nlogger.error (nano::log::type::ipc, "Error reading: ", ec.message ()); } else if (bytes_transferred_a > 0) { @@ -260,10 +254,11 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f auto buffer (std::make_shared> ()); buffer->insert (buffer->end (), reinterpret_cast (&big), reinterpret_cast (&big) + sizeof (std::uint32_t)); buffer->insert (buffer->end (), body.begin (), body.end ()); - if (this_l->node.config.logging.log_ipc ()) - { - this_l->node.logger.always_log (boost::str (boost::format ("IPC/RPC request %1% completed in: %2% %3%") % request_id_l % this_l->session_timer.stop ().count () % this_l->session_timer.unit ())); - } + + this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/RPC request {} completed in: {} {}", + request_id_l, + this_l->session_timer.stop ().count (), + this_l->session_timer.unit ()); this_l->timer_start (std::chrono::seconds (this_l->config_transport.io_timeout)); this_l->queued_write (boost::asio::buffer (buffer->data (), buffer->size ()), [this_l, buffer] (boost::system::error_code const & error_a, std::size_t size_a) { @@ -272,9 +267,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f { this_l->read_next_request (); } - else if (this_l->node.config.logging.log_ipc ()) + else { - this_l->node.logger.always_log ("IPC: Write failed: ", error_a.message ()); + this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: ", error_a.message ()); } }); @@ -307,10 +302,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f this_l->active_encoding = static_cast (encoding); if (this_l->buffer[nano::ipc::preamble_offset::lead] != 'N' || this_l->buffer[nano::ipc::preamble_offset::reserved_1] != 0 || this_l->buffer[nano::ipc::preamble_offset::reserved_2] != 0) { - if (this_l->node.config.logging.log_ipc ()) - { - this_l->node.logger.always_log ("IPC: Invalid preamble"); - } + this_l->node.nlogger.error (nano::log::type::ipc, "Invalid preamble"); } else if (encoding == static_cast (nano::ipc::payload_encoding::json_v1) || encoding == static_cast (nano::ipc::payload_encoding::json_v1_unsafe)) { @@ -344,10 +336,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f if (encoding == static_cast (nano::ipc::payload_encoding::flatbuffers_json)) { this_l->flatbuffers_handler->process_json (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr const & body) { - if (this_l->node.config.logging.log_ipc ()) - { - this_l->node.logger.always_log (boost::str (boost::format ("IPC/Flatbuffer request completed in: %1% %2%") % this_l->session_timer.stop ().count () % this_l->session_timer.unit ())); - } + this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", + this_l->session_timer.stop ().count (), + this_l->session_timer.unit ()); auto big_endian_length = std::make_shared (boost::endian::native_to_big (static_cast (body->size ()))); boost::array buffers = { @@ -360,9 +351,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f { this_l->read_next_request (); } - else if (this_l->node.config.logging.log_ipc ()) + else { - this_l->node.logger.always_log ("IPC: Write failed: ", error_a.message ()); + this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); } }); }); @@ -370,10 +361,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f else { this_l->flatbuffers_handler->process (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr const & fbb) { - if (this_l->node.config.logging.log_ipc ()) - { - this_l->node.logger.always_log (boost::str (boost::format ("IPC/Flatbuffer request completed in: %1% %2%") % this_l->session_timer.stop ().count () % this_l->session_timer.unit ())); - } + this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", + this_l->session_timer.stop ().count (), + this_l->session_timer.unit ()); auto big_endian_length = std::make_shared (boost::endian::native_to_big (static_cast (fbb->GetSize ()))); boost::array buffers = { @@ -386,9 +376,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f { this_l->read_next_request (); } - else if (this_l->node.config.logging.log_ipc ()) + else { - this_l->node.logger.always_log ("IPC: Write failed: ", error_a.message ()); + this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); } }); }); @@ -396,9 +386,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f }); }); } - else if (this_l->node.config.logging.log_ipc ()) + else { - this_l->node.logger.always_log ("IPC: Unsupported payload encoding"); + this_l->node.nlogger.error (nano::log::type::ipc, "Unsupported payload encoding"); } }); } @@ -523,7 +513,7 @@ class socket_transport : public nano::ipc::transport } else { - node->logger.always_log ("IPC: acceptor error: ", ec.message ()); + node->nlogger.error (nano::log::type::ipc, "Acceptor error: ", ec.message ()); } if (ec != boost::asio::error::operation_aborted && acceptor->is_open ()) @@ -532,7 +522,7 @@ class socket_transport : public nano::ipc::transport } else { - node->logger.always_log ("IPC: shutting down"); + node->nlogger.info (nano::log::type::ipc, "Shutting down"); } }); } @@ -625,7 +615,7 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co boost::asio::local::stream_protocol::endpoint ep{ node_a.config.ipc_config.transport_domain.path }; transports.push_back (std::make_shared (*this, ep, node_a.config.ipc_config.transport_domain, threads)); #else - node.logger.always_log ("IPC: Domain sockets are not supported on this platform"); + node.nlogger.error (nano::log::type::ipc_server, "Domain sockets are not supported on this platform"); #endif } @@ -635,7 +625,7 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co transports.push_back (std::make_shared (*this, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v6 (), node_a.config.ipc_config.transport_tcp.port), node_a.config.ipc_config.transport_tcp, threads)); } - node.logger.always_log ("IPC: server started"); + node.nlogger.debug (nano::log::type::ipc_server, "Server started"); if (!transports.empty ()) { @@ -644,13 +634,13 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co } catch (std::runtime_error const & ex) { - node.logger.always_log ("IPC: ", ex.what ()); + node.nlogger.error (nano::log::type::ipc_server, "Error: {}", ex.what ()); } } nano::ipc::ipc_server::~ipc_server () { - node.logger.always_log ("IPC: server stopped"); + node.nlogger.debug (nano::log::type::ipc_server, "Server stopped"); } void nano::ipc::ipc_server::stop () @@ -690,9 +680,7 @@ nano::error nano::ipc::ipc_server::reload_access_config () nano::error access_config_error (nano::ipc::read_access_config_toml (node.application_path, access)); if (access_config_error) { - auto error (boost::str (boost::format ("IPC: invalid access configuration file: %1%") % access_config_error.get_message ())); - std::cerr << error << std::endl; - node.logger.always_log (error); + node.nlogger.error (nano::log::type::ipc_server, "Invalid access configuration file: {}", access_config_error.get_message ()); } return access_config_error; } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3e6683da74..3bd22bf980 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -2955,7 +2955,7 @@ void nano::json_handler::password_change () rpc_l->response_l.put ("changed", error ? "0" : "1"); if (!error) { - rpc_l->node.logger.try_log ("Wallet password changed"); + rpc_l->node.nlogger.warn (nano::log::type::rpc, "Wallet password changed"); } } } @@ -4773,7 +4773,8 @@ void nano::json_handler::wallet_lock () empty.clear (); wallet->store.password.value_set (empty); response_l.put ("locked", "1"); - node.logger.try_log ("Wallet locked"); + + node.nlogger.warn (nano::log::type::rpc, "Wallet locked"); } response_errors (); } diff --git a/nano/node/make_store.cpp b/nano/node/make_store.cpp index 7f24c649cf..fda5c9ac20 100644 --- a/nano/node/make_store.cpp +++ b/nano/node/make_store.cpp @@ -2,7 +2,7 @@ #include #include -std::unique_ptr nano::make_store (nano::logger_mt & logger, std::filesystem::path const & path, nano::ledger_constants & constants, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) +std::unique_ptr nano::make_store (nano::nlogger & logger, std::filesystem::path const & path, nano::ledger_constants & constants, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) { if (rocksdb_config.enable) { diff --git a/nano/node/make_store.hpp b/nano/node/make_store.hpp index 1e7bdd2dc1..b467c07ce8 100644 --- a/nano/node/make_store.hpp +++ b/nano/node/make_store.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include @@ -22,5 +22,5 @@ class component; namespace nano { -std::unique_ptr make_store (nano::logger_mt & logger, std::filesystem::path const & path, nano::ledger_constants & constants, bool open_read_only = false, bool add_db_postfix = true, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); +std::unique_ptr make_store (nano::nlogger &, std::filesystem::path const & path, nano::ledger_constants & constants, bool open_read_only = false, bool add_db_postfix = true, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); } diff --git a/nano/node/messages.cpp b/nano/node/messages.cpp index 3b6079b432..0631dcddfa 100644 --- a/nano/node/messages.cpp +++ b/nano/node/messages.cpp @@ -82,86 +82,6 @@ bool nano::message_header::deserialize (nano::stream & stream_a) return error; } -std::string nano::to_string (nano::message_type type) -{ - switch (type) - { - case nano::message_type::invalid: - return "invalid"; - case nano::message_type::not_a_type: - return "not_a_type"; - case nano::message_type::keepalive: - return "keepalive"; - case nano::message_type::publish: - return "publish"; - case nano::message_type::confirm_req: - return "confirm_req"; - case nano::message_type::confirm_ack: - return "confirm_ack"; - case nano::message_type::bulk_pull: - return "bulk_pull"; - case nano::message_type::bulk_push: - return "bulk_push"; - case nano::message_type::frontier_req: - return "frontier_req"; - case nano::message_type::node_id_handshake: - return "node_id_handshake"; - case nano::message_type::bulk_pull_account: - return "bulk_pull_account"; - case nano::message_type::telemetry_req: - return "telemetry_req"; - case nano::message_type::telemetry_ack: - return "telemetry_ack"; - case nano::message_type::asc_pull_req: - return "asc_pull_req"; - case nano::message_type::asc_pull_ack: - return "asc_pull_ack"; - // default case intentionally omitted to cause warnings for unhandled enums - } - - return "n/a"; -} - -nano::stat::detail nano::to_stat_detail (nano::message_type type) -{ - switch (type) - { - case nano::message_type::invalid: - return nano::stat::detail::invalid; - case nano::message_type::not_a_type: - return nano::stat::detail::not_a_type; - case nano::message_type::keepalive: - return nano::stat::detail::keepalive; - case nano::message_type::publish: - return nano::stat::detail::publish; - case nano::message_type::confirm_req: - return nano::stat::detail::confirm_req; - case nano::message_type::confirm_ack: - return nano::stat::detail::confirm_ack; - case nano::message_type::bulk_pull: - return nano::stat::detail::bulk_pull; - case nano::message_type::bulk_push: - return nano::stat::detail::bulk_push; - case nano::message_type::frontier_req: - return nano::stat::detail::frontier_req; - case nano::message_type::node_id_handshake: - return nano::stat::detail::node_id_handshake; - case nano::message_type::bulk_pull_account: - return nano::stat::detail::bulk_pull_account; - case nano::message_type::telemetry_req: - return nano::stat::detail::telemetry_req; - case nano::message_type::telemetry_ack: - return nano::stat::detail::telemetry_ack; - case nano::message_type::asc_pull_req: - return nano::stat::detail::asc_pull_req; - case nano::message_type::asc_pull_ack: - return nano::stat::detail::asc_pull_ack; - // default case intentionally omitted to cause warnings for unhandled enums - } - debug_assert (false); - return {}; -} - std::string nano::message_header::to_string () const { // Cast to uint16_t to get integer value since uint8_t is treated as an unsigned char in string formatting. @@ -169,11 +89,11 @@ std::string nano::message_header::to_string () const uint16_t version_max_l = static_cast (version_max); uint16_t version_using_l = static_cast (version_using); uint16_t version_min_l = static_cast (version_min); - std::string type_text = nano::to_string (type); + auto type_text = nano::to_string (type); std::stringstream stream; - stream << boost::format ("NetID: %1%(%2%), ") % nano::to_string_hex (static_cast (network)) % nano::network::to_string (network); + stream << boost::format ("NetID: %1%(%2%), ") % nano::to_string_hex (static_cast (network)) % nano::to_string (network); stream << boost::format ("VerMaxUsingMin: %1%/%2%/%3%, ") % version_max_l % version_using_l % version_min_l; stream << boost::format ("MsgType: %1%(%2%), ") % type_l % type_text; stream << boost::format ("Extensions: %1%") % nano::to_string_hex (static_cast (extensions.to_ulong ())); @@ -2068,3 +1988,87 @@ void nano::asc_pull_ack::frontiers_payload::deserialize (nano::stream & stream) current = deserialize_frontier (stream); } } + +/* + * + */ + +std::string_view nano::to_string (nano::message_type type) +{ + switch (type) + { + case nano::message_type::invalid: + return "invalid"; + case nano::message_type::not_a_type: + return "not_a_type"; + case nano::message_type::keepalive: + return "keepalive"; + case nano::message_type::publish: + return "publish"; + case nano::message_type::confirm_req: + return "confirm_req"; + case nano::message_type::confirm_ack: + return "confirm_ack"; + case nano::message_type::bulk_pull: + return "bulk_pull"; + case nano::message_type::bulk_push: + return "bulk_push"; + case nano::message_type::frontier_req: + return "frontier_req"; + case nano::message_type::node_id_handshake: + return "node_id_handshake"; + case nano::message_type::bulk_pull_account: + return "bulk_pull_account"; + case nano::message_type::telemetry_req: + return "telemetry_req"; + case nano::message_type::telemetry_ack: + return "telemetry_ack"; + case nano::message_type::asc_pull_req: + return "asc_pull_req"; + case nano::message_type::asc_pull_ack: + return "asc_pull_ack"; + // default case intentionally omitted to cause warnings for unhandled enums + } + + return "n/a"; +} + +nano::stat::detail nano::to_stat_detail (nano::message_type type) +{ + switch (type) + { + case nano::message_type::invalid: + return nano::stat::detail::invalid; + case nano::message_type::not_a_type: + return nano::stat::detail::not_a_type; + case nano::message_type::keepalive: + return nano::stat::detail::keepalive; + case nano::message_type::publish: + return nano::stat::detail::publish; + case nano::message_type::confirm_req: + return nano::stat::detail::confirm_req; + case nano::message_type::confirm_ack: + return nano::stat::detail::confirm_ack; + case nano::message_type::bulk_pull: + return nano::stat::detail::bulk_pull; + case nano::message_type::bulk_push: + return nano::stat::detail::bulk_push; + case nano::message_type::frontier_req: + return nano::stat::detail::frontier_req; + case nano::message_type::node_id_handshake: + return nano::stat::detail::node_id_handshake; + case nano::message_type::bulk_pull_account: + return nano::stat::detail::bulk_pull_account; + case nano::message_type::telemetry_req: + return nano::stat::detail::telemetry_req; + case nano::message_type::telemetry_ack: + return nano::stat::detail::telemetry_ack; + case nano::message_type::asc_pull_req: + return nano::stat::detail::asc_pull_req; + case nano::message_type::asc_pull_ack: + return nano::stat::detail::asc_pull_ack; + // default case intentionally omitted to cause warnings for unhandled enums + } + debug_assert (false); + return {}; +} diff --git a/nano/node/messages.hpp b/nano/node/messages.hpp index 5c22118695..d662054bdb 100644 --- a/nano/node/messages.hpp +++ b/nano/node/messages.hpp @@ -44,8 +44,8 @@ enum class message_type : uint8_t asc_pull_ack = 0x0f, }; -std::string to_string (message_type); -stat::detail to_stat_detail (message_type); +std::string_view to_string (nano::message_type); +stat::detail to_stat_detail (nano::message_type); enum class bulk_pull_account_flags : uint8_t { diff --git a/nano/node/network.cpp b/nano/node/network.cpp index a9c1974399..ab81aa6b0a 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -27,10 +28,9 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : port (port_a), disconnect_observer ([] () {}) { - // TCP for (std::size_t i = 0; i < node.config.network_threads && !node.flags.disable_tcp_realtime; ++i) { - packet_processing_threads.emplace_back (nano::thread_attributes::get_default (), [this] () { + packet_processing_threads.emplace_back (nano::thread_attributes::get_default (), [this, i] () { nano::thread_role::set (nano::thread_role::name::packet_processing); try { @@ -38,28 +38,24 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : } catch (boost::system::error_code & ec) { - this->node.logger.always_log (FATAL_LOG_PREFIX, ec.message ()); + node.nlogger.critical (nano::log::type::network, "Error: {}", ec.message ()); release_assert (false); } catch (std::error_code & ec) { - this->node.logger.always_log (FATAL_LOG_PREFIX, ec.message ()); + node.nlogger.critical (nano::log::type::network, "Error: {}", ec.message ()); release_assert (false); } catch (std::runtime_error & err) { - this->node.logger.always_log (FATAL_LOG_PREFIX, err.what ()); + node.nlogger.critical (nano::log::type::network, "Error: {}", err.what ()); release_assert (false); } catch (...) { - this->node.logger.always_log (FATAL_LOG_PREFIX, "Unknown exception"); + node.nlogger.critical (nano::log::type::network, "Unknown error"); release_assert (false); } - if (this->node.config.logging.network_packet_logging ()) - { - this->node.logger.try_log ("Exiting TCP packet processing thread"); - } }); } } @@ -131,10 +127,11 @@ void nano::network::send_node_id_handshake (std::shared_ptrget_endpoint () % (query ? query->cookie.to_string () : std::string ("[none]")) % (respond_to ? respond_to->to_string () : std::string ("[none]")) % (response ? response->signature.to_string () : std::string ("[none]")))); - } + node.nlogger.debug (nano::log::type::network, "Node ID handshake sent to: {} (query: {}, respond to: {}, signature: {})", + nano::util::to_str (channel_a->get_endpoint ()), + (query ? query->cookie.to_string () : ""), + (respond_to ? respond_to->to_string () : ""), + (response ? response->signature.to_string () : "")); channel_a->send (message); } @@ -260,10 +257,6 @@ void nano::network::broadcast_confirm_req (std::shared_ptr const & void nano::network::broadcast_confirm_req_base (std::shared_ptr const & block_a, std::shared_ptr>> const & endpoints_a, unsigned delay_a, bool resumption) { std::size_t const max_reps = 10; - if (!resumption && node.config.logging.network_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Broadcasting confirm req for block %1% to %2% representatives") % block_a->hash ().to_string () % endpoints_a->size ())); - } auto count (0); while (!endpoints_a->empty () && count < max_reps) { @@ -288,11 +281,6 @@ void nano::network::broadcast_confirm_req_base (std::shared_ptr con void nano::network::broadcast_confirm_req_batched_many (std::unordered_map, std::deque>> request_bundle_a, std::function callback_a, unsigned delay_a, bool resumption_a) { - if (!resumption_a && node.config.logging.network_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Broadcasting batch confirm req to %1% representatives") % request_bundle_a.size ())); - } - for (auto i (request_bundle_a.begin ()), n (request_bundle_a.end ()); i != n;) { std::vector> roots_hashes_l; @@ -365,18 +353,13 @@ class network_message_visitor : public nano::message_visitor { public: network_message_visitor (nano::node & node_a, std::shared_ptr const & channel_a) : - node (node_a), - channel (channel_a) + node{ node_a }, + channel{ channel_a } { } void keepalive (nano::keepalive const & message_a) override { - if (node.config.logging.network_keepalive_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Received keepalive message from %1%") % channel->to_string ())); - } - node.network.merge_peers (message_a.peers); // Check for special node port data @@ -393,11 +376,6 @@ class network_message_visitor : public nano::message_visitor void publish (nano::publish const & message_a) override { - if (node.config.logging.network_message_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Publish message from %1% for %2%") % channel->to_string () % message_a.block->hash ().to_string ())); - } - if (!node.block_processor.full ()) { node.process_active (message_a.block); @@ -411,14 +389,6 @@ class network_message_visitor : public nano::message_visitor void confirm_req (nano::confirm_req const & message_a) override { - if (node.config.logging.network_message_logging ()) - { - if (!message_a.roots_hashes.empty ()) - { - node.logger.try_log (boost::str (boost::format ("Confirm_req message from %1% for hashes:roots %2%") % channel->to_string () % message_a.roots_string ())); - } - } - // Don't load nodes with disabled voting if (node.config.enable_voting && node.wallets.reps ().voting > 0) { @@ -431,11 +401,6 @@ class network_message_visitor : public nano::message_visitor void confirm_ack (nano::confirm_ack const & message_a) override { - if (node.config.logging.network_message_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Received confirm_ack message from %1% for %2% timestamp %3%") % channel->to_string () % message_a.vote->hashes_string () % std::to_string (message_a.vote->timestamp ()))); - } - if (!message_a.vote->account.is_zero ()) { node.vote_processor.vote (message_a.vote, channel); @@ -469,11 +434,6 @@ class network_message_visitor : public nano::message_visitor void telemetry_req (nano::telemetry_req const & message_a) override { - if (node.config.logging.network_telemetry_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Telemetry_req message from %1%") % channel->to_string ())); - } - // Send an empty telemetry_ack if we do not want, just to acknowledge that we have received the message to // remove any timeouts on the server side waiting for a message. nano::telemetry_ack telemetry_ack{ node.network_params.network }; @@ -487,11 +447,6 @@ class network_message_visitor : public nano::message_visitor void telemetry_ack (nano::telemetry_ack const & message_a) override { - if (node.config.logging.network_telemetry_logging ()) - { - node.logger.try_log (boost::str (boost::format ("Received telemetry_ack message from %1%") % channel->to_string ())); - } - node.telemetry.process (message_a, channel); } @@ -515,7 +470,7 @@ void nano::network::process_message (nano::message const & message, std::shared_ { node.stats.inc (nano::stat::type::message, nano::to_stat_detail (message.header.type), nano::stat::dir::in); - network_message_visitor visitor (node, channel); + network_message_visitor visitor{ node, channel }; message.visit (visitor); } @@ -998,23 +953,3 @@ std::unique_ptr nano::syn_cookies::collect_conta composite->add_component (std::make_unique (container_info{ "syn_cookies_per_ip", syn_cookies_per_ip_count, sizeof (decltype (cookies_per_ip)::value_type) })); return composite; } - -std::string nano::network::to_string (nano::networks network) -{ - switch (network) - { - case nano::networks::invalid: - return "invalid"; - case nano::networks::nano_beta_network: - return "beta"; - case nano::networks::nano_dev_network: - return "dev"; - case nano::networks::nano_live_network: - return "live"; - case nano::networks::nano_test_network: - return "test"; - // default case intentionally omitted to cause warnings for unhandled enums - } - - return "n/a"; -} diff --git a/nano/node/network.hpp b/nano/node/network.hpp index 56f6f23b86..f0785d9441 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -133,8 +134,6 @@ class network final std::optional prepare_handshake_query (nano::endpoint const & remote_endpoint); nano::node_id_handshake::response_payload prepare_handshake_response (nano::node_id_handshake::query_payload const & query, bool v2) const; - static std::string to_string (nano::networks); - private: void process_message (nano::message const &, std::shared_ptr const &); @@ -158,5 +157,6 @@ class network final static std::size_t const confirm_req_hashes_max = 7; static std::size_t const confirm_ack_hashes_max = 12; }; + std::unique_ptr collect_container_info (network & network, std::string const & name); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 2ec288a875..679ccf2d90 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -84,7 +84,7 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) } else { - node_l->logger.try_log (boost::str (boost::format ("Error resolving address: %1%:%2%: %3%") % address_a % port_a % ec.message ())); + node_l->nlogger.error (nano::log::type::node, "Error resolving address for keepalive: {}:{} ({})", address_a, port_a, ec.message ()); } }); } @@ -103,13 +103,14 @@ std::unique_ptr nano::collect_container_info (re return composite; } -nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path, nano::logger_mt & logger) +nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path, nano::nlogger & nlogger) { auto node_private_key_path = application_path / "node_id_private.key"; std::ifstream ifs (node_private_key_path.c_str ()); if (ifs.good ()) { - logger.always_log (boost::str (boost::format ("%1% exists, reading node id from it") % node_private_key_path.string ())); + nlogger.debug (nano::log::type::node, "Reading node id from: '{}'", node_private_key_path.string ()); + std::string node_private_key; ifs >> node_private_key; release_assert (node_private_key.size () == 64); @@ -119,7 +120,8 @@ nano::keypair nano::load_or_create_node_id (std::filesystem::path const & applic else { // no node_id found, generate new one - logger.always_log (boost::str (boost::format ("%1% does not exist, creating a new node_id") % node_private_key_path.string ())); + nlogger.debug (nano::log::type::node, "Generating a new node id, saving to: '{}'", node_private_key_path.string ()); + nano::keypair kp; std::ofstream ofs (node_private_key_path.c_str (), std::ofstream::out | std::ofstream::trunc); ofs << kp.prv.to_string () << std::endl @@ -141,6 +143,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons node_initialized_latch (1), config (config_a), network_params{ config.network_params }, + nlogger{ "node" }, stats (config.stats_config), workers{ config.background_threads, nano::thread_role::name::worker }, bootstrap_workers{ config.bootstrap_serving_threads, nano::thread_role::name::bootstrap_worker }, @@ -148,7 +151,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons work (work_a), distributed_work (*this), logger (config_a.logging.min_time_between_log_output), - store_impl (nano::make_store (logger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), + store_impl (nano::make_store (nlogger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), store (*store_impl), unchecked{ stats, flags.disable_block_processor_unchecked_deletion }, wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), @@ -174,13 +177,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons application_path (application_path_a), port_mapping (*this), rep_crawler (*this), - vote_processor (active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params), + vote_processor (active, observers, stats, config, flags, nlogger, online_reps, rep_crawler, ledger, network_params), warmed_up (0), block_processor (*this, write_database_queue), online_reps (ledger, config), history{ config.network_params.voting }, vote_uniquer{}, - confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode), + confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, nlogger, node_initialized_latch, flags.confirmation_height_processor_mode), vote_cache{ config.vote_cache, stats }, generator{ config, ledger, wallets, vote_processor, history, network, stats, /* non-final */ false }, final_generator{ config, ledger, wallets, vote_processor, history, network, stats, /* final */ true }, @@ -191,8 +194,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons wallets (wallets_store.init_error (), *this), backlog{ nano::backlog_population_config (config), store, stats }, ascendboot{ config, block_processor, ledger, network, stats }, - websocket{ config.websocket_config, observers, wallets, ledger, io_ctx, logger }, - epoch_upgrader{ *this, ledger, store, network_params, logger }, + websocket{ config.websocket_config, observers, wallets, ledger, io_ctx, nlogger }, + epoch_upgrader{ *this, ledger, store, network_params, nlogger }, startup_time (std::chrono::steady_clock::now ()), node_seq (seq), block_broadcast{ network, block_arrival, !flags.disable_block_processor_republishing }, @@ -200,6 +203,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons gap_tracker{ gap_cache }, process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } { + nlogger.debug (nano::log::type::node, "Constructing node..."); + block_broadcast.connect (block_processor); block_publisher.connect (block_processor); gap_tracker.connect (block_processor); @@ -288,10 +293,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons } else { - if (node_l->config.logging.callback_logging ()) - { - node_l->logger.always_log (boost::str (boost::format ("Error resolving callback: %1%:%2%: %3%") % address % port % ec.message ())); - } + node_l->nlogger.error (nano::log::type::rpc_callbacks, "Error resolving callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); @@ -338,26 +340,24 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons this->distributed_work.cancel (root_a); }); - logger.always_log ("Node starting, version: ", NANO_VERSION_STRING); - logger.always_log ("Build information: ", BUILD_INFO); - logger.always_log ("Database backend: ", store.vendor_get ()); - auto const network_label = network_params.network.get_current_network_as_string (); - logger.always_log ("Active network: ", network_label); - logger.always_log (boost::str (boost::format ("Work pool running %1% threads %2%") % work.threads.size () % (work.opencl ? "(1 for OpenCL)" : ""))); - logger.always_log (boost::str (boost::format ("%1% work peers configured") % config.work_peers.size ())); - if (!work_generation_enabled ()) - { - logger.always_log ("Work generation is disabled"); - } + nlogger.info (nano::log::type::node, "Node starting, version: {}", NANO_VERSION_STRING); + nlogger.info (nano::log::type::node, "Build information: {}", BUILD_INFO); + nlogger.info (nano::log::type::node, "Active network: {}", network_label); + nlogger.info (nano::log::type::node, "Database backend: {}", store.vendor_get ()); + nlogger.info (nano::log::type::node, "Data path: {}", application_path.string ()); + nlogger.info (nano::log::type::node, "Work pool threads: {} ({})", work.threads.size (), (work.opencl ? "OpenCL" : "CPU")); + nlogger.info (nano::log::type::node, "Work peers: {}", config.work_peers.size ()); - if (config.logging.node_lifetime_tracing ()) + if (!work_generation_enabled ()) { - logger.always_log ("Constructing node"); + nlogger.info (nano::log::type::node, "Work generation is disabled"); } - logger.always_log (boost::str (boost::format ("Outbound Voting Bandwidth limited to %1% bytes per second, burst ratio %2%") % config.bandwidth_limit % config.bandwidth_limit_burst_ratio)); + nlogger.info (nano::log::type::node, "Outbound bandwidth limit: {} bytes/s, burst ratio: {}", + config.bandwidth_limit, + config.bandwidth_limit_burst_ratio); // First do a pass with a read to see if any writing needs doing, this saves needing to open a write lock (and potentially blocking) auto is_initialized (false); @@ -375,59 +375,72 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons if (!ledger.block_or_pruned_exists (config.network_params.ledger.genesis->hash ())) { - std::stringstream ss; - ss << "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, " - "and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first."; + nlogger.critical (nano::log::type::node, "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first."); + if (network_params.network.is_beta_network ()) { - ss << " Beta network may have reset, try clearing database files"; + nlogger.critical (nano::log::type::node, "Beta network may have reset, try clearing database files"); } - auto const str = ss.str (); - logger.always_log (str); - std::cerr << str << std::endl; std::exit (1); } if (config.enable_voting) { - std::ostringstream stream; - stream << "Voting is enabled, more system resources will be used"; - auto voting (wallets.reps ().voting); - if (voting > 0) + auto reps = wallets.reps (); + nlogger.info (nano::log::type::node, "Voting is enabled, more system resources will be used, local representatives: {}", reps.accounts.size ()); + for (auto const & account : reps.accounts) { - stream << ". " << voting << " representative(s) are configured"; - if (voting > 1) - { - stream << ". Voting with more than one representative can limit performance"; - } + nlogger.info (nano::log::type::node, "Local representative: {}", account.to_account ()); + } + if (reps.accounts.size () > 1) + { + nlogger.warn (nano::log::type::node, "Voting with more than one representative can limit performance"); } - logger.always_log (stream.str ()); } - node_id = nano::load_or_create_node_id (application_path, logger); - logger.always_log ("Node ID: ", node_id.pub.to_node_id ()); + node_id = nano::load_or_create_node_id (application_path, nlogger); + nlogger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ()); if ((network_params.network.is_live_network () || network_params.network.is_beta_network ()) && !flags.inactive_node) { auto const bootstrap_weights = get_bootstrap_weights (); + ledger.bootstrap_weight_max_blocks = bootstrap_weights.first; + + nlogger.info (nano::log::type::node, "Initial bootstrap height: {}", ledger.bootstrap_weight_max_blocks); + nlogger.info (nano::log::type::node, "Current ledger height: {}", ledger.cache.block_count.load ()); + // Use bootstrap weights if initial bootstrap is not completed const bool use_bootstrap_weight = ledger.cache.block_count < bootstrap_weights.first; if (use_bootstrap_weight) { + nlogger.info (nano::log::type::node, "Using predefined representative weights, since block count is less than bootstrap threshold"); + ledger.bootstrap_weights = bootstrap_weights.second; - for (auto const & rep : ledger.bootstrap_weights) + + nlogger.info (nano::log::type::node, "************************************ Bootstrap weights ************************************"); + + // Sort the weights + std::vector> sorted_weights (ledger.bootstrap_weights.begin (), ledger.bootstrap_weights.end ()); + std::sort (sorted_weights.begin (), sorted_weights.end (), [] (auto const & entry1, auto const & entry2) { + return entry1.second > entry2.second; + }); + + for (auto const & rep : sorted_weights) { - logger.always_log ("Using bootstrap rep weight: ", rep.first.to_account (), " -> ", nano::uint128_union (rep.second).format_balance (Mxrb_ratio, 0, true), " XRB"); + nlogger.info (nano::log::type::node, "Using bootstrap rep weight: {} -> {}", + rep.first.to_account (), + nano::uint128_union (rep.second).format_balance (Mxrb_ratio, 0, true)); } + + nlogger.info (nano::log::type::node, "************************************ ================= ************************************"); } - ledger.bootstrap_weight_max_blocks = bootstrap_weights.first; // Drop unchecked blocks if initial bootstrap is completed if (!flags.disable_unchecked_drop && !use_bootstrap_weight && !flags.read_only) { + nlogger.info (nano::log::type::node, "Dropping unchecked blocks..."); unchecked.clear (); - logger.always_log ("Dropping unchecked blocks"); } } @@ -437,16 +450,12 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons { if (config.enable_voting && !flags.inactive_node) { - std::string str = "Incompatibility detected between config node.enable_voting and existing pruned blocks"; - logger.always_log (str); - std::cerr << str << std::endl; + nlogger.critical (nano::log::type::node, "Incompatibility detected between config node.enable_voting and existing pruned blocks"); std::exit (1); } else if (!flags.enable_pruning && !flags.inactive_node) { - std::string str = "To start node with existing pruned blocks use launch flag --enable_pruning"; - logger.always_log (str); - std::cerr << str << std::endl; + nlogger.critical (nano::log::type::node, "To start node with existing pruned blocks use launch flag --enable_pruning"); std::exit (1); } } @@ -456,13 +465,11 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons nano::node::~node () { - if (config.logging.node_lifetime_tracing ()) - { - logger.always_log ("Destructing node"); - } + nlogger.debug (nano::log::type::node, "Destructing node..."); stop (); } +// TODO: Move to a separate class void nano::node::do_rpc_callback (boost::asio::ip::tcp::resolver::iterator i_a, std::string const & address, uint16_t port, std::shared_ptr const & target, std::shared_ptr const & body, std::shared_ptr const & resolver) { if (i_a != boost::asio::ip::tcp::resolver::iterator{}) @@ -494,41 +501,30 @@ void nano::node::do_rpc_callback (boost::asio::ip::tcp::resolver::iterator i_a, } else { - if (node_l->config.logging.callback_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Callback to %1%:%2% failed with status: %3%") % address % port % resp->result ())); - } + node_l->nlogger.error (nano::log::type::rpc_callbacks, "Callback to {}:{} failed [status: {}]", address, port, nano::util::to_str (resp->result ())); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } } else { - if (node_l->config.logging.callback_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Unable complete callback: %1%:%2%: %3%") % address % port % ec.message ())); - } + node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to complete callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); }; }); } else { - if (node_l->config.logging.callback_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Unable to send callback: %1%:%2%: %3%") % address % port % ec.message ())); - } + node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to send callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); } else { - if (node_l->config.logging.callback_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Unable to connect to callback address: %1%:%2%: %3%") % address % port % ec.message ())); - } + node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to connect to callback address: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); ++i_a; + node_l->do_rpc_callback (i_a, address, port, target, body, resolver); } }); @@ -655,7 +651,7 @@ void nano::node::start () network.port = tcp_listener->endpoint ().port (); } - logger.always_log (boost::str (boost::format ("Node started with peering port `%1%`.") % network.port)); + nlogger.info (nano::log::type::node, "Node peering port: {}", network.port.load ()); } if (!flags.disable_backup) @@ -702,7 +698,7 @@ void nano::node::stop () return; } - logger.always_log ("Node stopping"); + nlogger.info (nano::log::type::node, "Node stopping..."); // Cancels ongoing work generation tasks, which may be blocking other threads // No tasks may wait for work generation in I/O threads, or termination signal capturing will be unable to call node::stop() @@ -811,7 +807,7 @@ void nano::node::long_inactivity_cleanup () { store.online_weight.clear (transaction); store.peer.clear (transaction); - logger.always_log ("Removed records of peers and online weight after a long period of inactivity"); + nlogger.info (nano::log::type::node, "Removed records of peers and online weight after a long period of inactivity"); } } @@ -975,7 +971,7 @@ void nano::node::unchecked_cleanup () } if (!cleaning_list.empty ()) { - logger.always_log (boost::str (boost::format ("Deleting %1% old unchecked blocks") % cleaning_list.size ())); + nlogger.info (nano::log::type::node, "Deleting {} old unchecked blocks", cleaning_list.size ()); } // Delete old unchecked keys in batches while (!cleaning_list.empty ()) @@ -1056,7 +1052,7 @@ bool nano::node::collect_ledger_pruning_targets (std::deque & return !finish_transaction || last_account_a.is_zero (); } -void nano::node::ledger_pruning (uint64_t const batch_size_a, bool bootstrap_weight_reached_a, bool log_to_cout_a) +void nano::node::ledger_pruning (uint64_t const batch_size_a, bool bootstrap_weight_reached_a) { uint64_t const max_depth (config.max_pruning_depth != 0 ? config.max_pruning_depth : std::numeric_limits::max ()); uint64_t const cutoff_time (bootstrap_weight_reached_a ? nano::seconds_since_epoch () - config.max_pruning_age.count () : std::numeric_limits::max ()); @@ -1086,32 +1082,18 @@ void nano::node::ledger_pruning (uint64_t const batch_size_a, bool bootstrap_wei pruning_targets.pop_front (); } pruned_count += transaction_write_count; - auto log_message (boost::str (boost::format ("%1% blocks pruned") % pruned_count)); - if (!log_to_cout_a) - { - logger.try_log (log_message); - } - else - { - std::cout << log_message << std::endl; - } + + nlogger.debug (nano::log::type::prunning, "Pruned blocks: {}", pruned_count); } } - auto const log_message (boost::str (boost::format ("Total recently pruned block count: %1%") % pruned_count)); - if (!log_to_cout_a) - { - logger.always_log (log_message); - } - else - { - std::cout << log_message << std::endl; - } + + nlogger.debug (nano::log::type::prunning, "Total recently pruned block count: {}", pruned_count); } void nano::node::ongoing_ledger_pruning () { auto bootstrap_weight_reached (ledger.cache.block_count >= ledger.bootstrap_weight_max_blocks); - ledger_pruning (flags.block_processor_batch_size != 0 ? flags.block_processor_batch_size : 2 * 1024, bootstrap_weight_reached, false); + ledger_pruning (flags.block_processor_batch_size != 0 ? flags.block_processor_batch_size : 2 * 1024, bootstrap_weight_reached); auto const ledger_pruning_interval (bootstrap_weight_reached ? config.max_pruning_age : std::min (config.max_pruning_age, std::chrono::seconds (15 * 60))); auto this_l (shared ()); workers.add_timed_task (std::chrono::steady_clock::now () + ledger_pruning_interval, [this_l] () { @@ -1238,7 +1220,7 @@ void nano::node::add_initial_peers () { if (flags.disable_add_initial_peers) { - logger.always_log ("Skipping add_initial_peers because disable_add_initial_peers is set"); + nlogger.warn (nano::log::type::node, "Not adding initial peers because `disable_add_initial_peers` flag is set"); return; } @@ -1318,12 +1300,12 @@ void nano::node::receive_confirmed (store::transaction const & block_transaction { if (!ledger.block_or_pruned_exists (block_transaction_a, hash_a)) { - logger.try_log (boost::str (boost::format ("Confirmed block is missing: %1%") % hash_a.to_string ())); - debug_assert (false && "Confirmed block is missing"); + nlogger.warn (nano::log::type::node, "Confirmed block is missing: {}", hash_a.to_string ()); + debug_assert (false, "Confirmed block is missing"); } else { - logger.try_log (boost::str (boost::format ("Block %1% has already been received") % hash_a.to_string ())); + nlogger.warn (nano::log::type::node, "Block has already been received: {}", hash_a.to_string ()); } } } @@ -1504,13 +1486,14 @@ nano::node_wrapper::node_wrapper (std::filesystem::path const & path_a, std::fil io_context (std::make_shared ()), work{ network_params.network, 1 } { - boost::system::error_code error_chmod; - /* * @warning May throw a filesystem exception */ std::filesystem::create_directories (path_a); + + boost::system::error_code error_chmod; nano::set_secure_perm_directory (path_a, error_chmod); + nano::daemon_config daemon_config{ path_a, network_params }; auto error = nano::read_node_config_toml (config_path_a, daemon_config, node_flags_a.config_overrides); if (error) diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 4e7b567444..4b18661301 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -1,6 +1,8 @@ #pragma once #include +#include +#include #include #include #include @@ -106,7 +108,7 @@ class node final : public std::enable_shared_from_this void bootstrap_wallet (); void unchecked_cleanup (); bool collect_ledger_pruning_targets (std::deque &, nano::account &, uint64_t const, uint64_t const, uint64_t const); - void ledger_pruning (uint64_t const, bool, bool); + void ledger_pruning (uint64_t const, bool); void ongoing_ledger_pruning (); int price (nano::uint128_t const &, int); // The default difficulty updates to base only when the first epoch_2 block is processed @@ -144,6 +146,7 @@ class node final : public std::enable_shared_from_this boost::latch node_initialized_latch; nano::node_config config; nano::network_params & network_params; + nano::nlogger nlogger; nano::stats stats; nano::thread_pool workers; nano::thread_pool bootstrap_workers; @@ -228,7 +231,8 @@ class node final : public std::enable_shared_from_this void long_inactivity_cleanup (); }; -nano::keypair load_or_create_node_id (std::filesystem::path const & application_path, nano::logger_mt & logger); +nano::keypair load_or_create_node_id (std::filesystem::path const & application_path, nano::nlogger &); + std::unique_ptr collect_container_info (node & node, std::string const & name); nano::node_flags const & inactive_node_flag_defaults (); diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 0cc4116270..89221c53c7 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -46,6 +47,7 @@ class node_config bool upgrade_json (unsigned, nano::jsonconfig &); nano::account random_representative () const; + nano::network_params network_params; std::optional peering_port{}; nano::scheduler::optimistic_config optimistic_scheduler; diff --git a/nano/node/openclwork.cpp b/nano/node/openclwork.cpp index 8389a19fb3..e1d97f4e37 100644 --- a/nano/node/openclwork.cpp +++ b/nano/node/openclwork.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -249,7 +250,7 @@ void nano::opencl_environment::dump (std::ostream & stream) } } -nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logger_mt & logger_a, nano::work_thresholds & work) : +nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::nlogger & nlogger_a, nano::work_thresholds & work) : config (config_a), context (0), attempt_buffer (0), @@ -259,7 +260,7 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf program (0), kernel (0), queue (0), - logger (logger_a), + nlogger (nlogger_a), work{ work } { error_a |= config.platform >= environment_a.platforms.size (); @@ -343,85 +344,85 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf } else { - logger.always_log (boost::str (boost::format ("Bind argument 3 error %1%") % arg3_error)); + nlogger.error (nano::log::type::opencl_work, "Bind argument 3 error: {}", arg3_error); } } else { - logger.always_log (boost::str (boost::format ("Bind argument 2 error %1%") % arg2_error)); + nlogger.error (nano::log::type::opencl_work, "Bind argument 2 error: {}", arg2_error); } } else { - logger.always_log (boost::str (boost::format ("Bind argument 1 error %1%") % arg1_error)); + nlogger.error (nano::log::type::opencl_work, "Bind argument 1 error: {}", arg1_error); } } else { - logger.always_log (boost::str (boost::format ("Bind argument 0 error %1%") % arg0_error)); + nlogger.error (nano::log::type::opencl_work, "Bind argument 0 error: {}", arg0_error); } } else { - logger.always_log (boost::str (boost::format ("Create kernel error %1%") % kernel_error)); + nlogger.error (nano::log::type::opencl_work, "Create kernel error: {}", kernel_error); } } else { - logger.always_log (boost::str (boost::format ("Build program error %1%") % clBuildProgramError)); + nlogger.error (nano::log::type::opencl_work, "Build program error: {}", clBuildProgramError); for (auto i (selected_devices.begin ()), n (selected_devices.end ()); i != n; ++i) { std::size_t log_size (0); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size); std::vector log (log_size); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, log.size (), log.data (), nullptr); - logger.always_log (log.data ()); + nlogger.info (nano::log::type::opencl_work, "Device log: {}", log.data ()); } } } else { - logger.always_log (boost::str (boost::format ("Create program error %1%") % program_error)); + nlogger.error (nano::log::type::opencl_work, "Create program error: {}", program_error); } } else { - logger.always_log (boost::str (boost::format ("Difficulty buffer error %1%") % difficulty_error)); + nlogger.error (nano::log::type::opencl_work, "Difficulty buffer error: {}", difficulty_error); } } else { - logger.always_log (boost::str (boost::format ("Item buffer error %1%") % item_error)); + nlogger.error (nano::log::type::opencl_work, "Item buffer error: {}", item_error); } } else { - logger.always_log (boost::str (boost::format ("Result buffer error %1%") % result_error)); + nlogger.error (nano::log::type::opencl_work, "Result buffer error: {}", result_error); } } else { - logger.always_log (boost::str (boost::format ("Attempt buffer error %1%") % attempt_error)); + nlogger.error (nano::log::type::opencl_work, "Attempt buffer error: {}", attempt_error); } } else { - logger.always_log (boost::str (boost::format ("Unable to create command queue %1%") % queue_error)); + nlogger.error (nano::log::type::opencl_work, "Unable to create command queue: {}", queue_error); } } else { - logger.always_log (boost::str (boost::format ("Unable to create context %1%") % createContextError)); + nlogger.error (nano::log::type::opencl_work, "Unable to create context: {}", createContextError); } } else { - logger.always_log (boost::str (boost::format ("Requested device %1%, and only have %2%") % config.device % platform.devices.size ())); + nlogger.error (nano::log::type::opencl_work, "Requested device {} and only have {}", config.device, platform.devices.size ()); } } else { - logger.always_log (boost::str (boost::format ("Requested platform %1% and only have %2%") % config.platform % environment_a.platforms.size ())); + nlogger.error (nano::log::type::opencl_work, "Requested platform {} and only have {}", config.platform, environment_a.platforms.size ()); } } @@ -480,37 +481,37 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c else { error = true; - logger.always_log (boost::str (boost::format ("Error finishing queue %1%") % finishError)); + nlogger.error (nano::log::type::opencl_work, "Error finishing queue: {}", finishError); } } else { error = true; - logger.always_log (boost::str (boost::format ("Error reading result %1%") % read_error1)); + nlogger.error (nano::log::type::opencl_work, "Error reading result: {}", read_error1); } } else { error = true; - logger.always_log (boost::str (boost::format ("Error enqueueing kernel %1%") % enqueue_error)); + nlogger.error (nano::log::type::opencl_work, "Error enqueueing kernel: {}", enqueue_error); } } else { error = true; - logger.always_log (boost::str (boost::format ("Error writing item %1%") % write_error3)); + nlogger.error (nano::log::type::opencl_work, "Error writing difficulty: {}", write_error3); } } else { error = true; - logger.always_log (boost::str (boost::format ("Error writing item %1%") % write_error2)); + nlogger.error (nano::log::type::opencl_work, "Error writing item: {}", write_error2); } } else { error = true; - logger.always_log (boost::str (boost::format ("Error writing attempt %1%") % write_error1)); + nlogger.error (nano::log::type::opencl_work, "Error writing attempt: {}", write_error1); } } boost::optional value; @@ -521,19 +522,21 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c return value; } -std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logger_mt & logger_a, nano::work_thresholds & work) +std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::nlogger & nlogger_a, nano::work_thresholds & work) { std::unique_ptr result; if (create_a) { auto error (false); + nano::opencl_environment environment (error); std::stringstream stream; environment.dump (stream); - logger_a.always_log (stream.str ()); + nlogger_a.info (nano::log::type::opencl_work, "OpenCL environment: {}", stream.str ()); + if (!error) { - result.reset (new nano::opencl_work (error, config_a, environment, logger_a, work)); + result.reset (new nano::opencl_work (error, config_a, environment, nlogger_a, work)); if (error) { result.reset (); diff --git a/nano/node/openclwork.hpp b/nano/node/openclwork.hpp index 2f452e092e..de76e6e416 100644 --- a/nano/node/openclwork.hpp +++ b/nano/node/openclwork.hpp @@ -21,7 +21,7 @@ namespace nano { extern bool opencl_loaded; -class logger_mt; +class nlogger; class opencl_platform { public: @@ -40,11 +40,11 @@ class work_pool; class opencl_work { public: - opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::logger_mt &, nano::work_thresholds & work); + opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::nlogger &, nano::work_thresholds & work); ~opencl_work (); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const, std::atomic &); - static std::unique_ptr create (bool, nano::opencl_config const &, nano::logger_mt &, nano::work_thresholds & work); + static std::unique_ptr create (bool, nano::opencl_config const &, nano::nlogger &, nano::work_thresholds & work); nano::opencl_config const & config; nano::mutex mutex; cl_context context; @@ -56,7 +56,7 @@ class opencl_work cl_kernel kernel; cl_command_queue queue; nano::xorshift1024star rand; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::work_thresholds & work; }; } diff --git a/nano/node/portmapping.cpp b/nano/node/portmapping.cpp index 690b7ce907..15a5d08a10 100644 --- a/nano/node/portmapping.cpp +++ b/nano/node/portmapping.cpp @@ -60,17 +60,19 @@ void nano::port_mapping::refresh_devices () std::array local_address_l; local_address_l.fill (0); auto igd_error_l (UPNP_GetValidIGD (upnp_l.devices, &upnp_l.urls, &upnp_l.data, local_address_l.data (), sizeof (local_address_l))); - if (check_count % 15 == 0 || node.config.logging.upnp_details_logging ()) + + // Bump logging level periodically + node.nlogger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, + nano::log::type::upnp, "UPnP local address {}, discovery: {}, IGD search: {}", + local_address_l.data (), + discover_error_l, + igd_error_l); + + for (auto i (upnp_l.devices); i != nullptr; i = i->pNext) { - node.logger.always_log (boost::str (boost::format ("UPnP local address: %1%, discovery: %2%, IGD search: %3%") % local_address_l.data () % discover_error_l % igd_error_l)); - if (node.config.logging.upnp_details_logging ()) - { - for (auto i (upnp_l.devices); i != nullptr; i = i->pNext) - { - node.logger.always_log (boost::str (boost::format ("UPnP device url: %1% st: %2% usn: %3%") % i->descURL % i->st % i->usn)); - } - } + node.nlogger.debug (nano::log::type::upnp, "UPnP device url: {}, st: {}, usn: {}", i->descURL, i->st, i->usn); } + // Update port mapping nano::lock_guard guard_l (mutex); upnp = std::move (upnp_l); @@ -114,14 +116,23 @@ void nano::port_mapping::refresh_mapping () if (add_port_mapping_error_l == UPNPCOMMAND_SUCCESS) { protocol.external_port = static_cast (std::atoi (config_port_l.data ())); - auto fmt = boost::format ("UPnP %1% %2%:%3% mapped to %4%") % protocol.name % protocol.external_address % config_port_l % node_port_l; - node.logger.always_log (boost::str (fmt)); + + node.nlogger.info (nano::log::type::upnp, "UPnP {} {}:{} mapped to: {}", + protocol.name, + protocol.external_address.to_string (), + config_port_l, + node_port_l); } else { protocol.external_port = 0; - auto fmt = boost::format ("UPnP %1% %2%:%3% FAILED") % protocol.name % add_port_mapping_error_l % strupnperror (add_port_mapping_error_l); - node.logger.always_log (boost::str (fmt)); + + node.nlogger.warn (nano::log::type::upnp, "UPnP {} {}:{} failed: {} ({})", + protocol.name, + protocol.external_address.to_string (), + config_port_l, + add_port_mapping_error_l, + strupnperror (add_port_mapping_error_l)); } } } @@ -149,12 +160,19 @@ bool nano::port_mapping::check_lost_or_old_mapping () if (verify_port_mapping_error_l != UPNPCOMMAND_SUCCESS) { result_l = true; - node.logger.always_log (boost::str (boost::format ("UPNP_GetSpecificPortMappingEntry failed %1%: %2%") % verify_port_mapping_error_l % strupnperror (verify_port_mapping_error_l))); + + node.nlogger.warn (nano::log::type::upnp, "UPnP get specific port mapping failed: {} ({})", + verify_port_mapping_error_l, + strupnperror (verify_port_mapping_error_l)); } if (!recent_lease) { result_l = true; - node.logger.always_log (boost::str (boost::format ("UPnP leasing time getting old, remaining time: %1%, lease time: %2%, below the threshold: %3%") % remaining_from_port_mapping % lease_duration % lease_duration_divided_by_two)); + + node.nlogger.info (nano::log::type::upnp, "UPnP lease time getting old, remaining time: {}, lease time: {}, below the threshold: {}", + remaining_from_port_mapping, + lease_duration, + lease_duration_divided_by_two); } std::array external_address_l; external_address_l.fill (0); @@ -168,12 +186,19 @@ bool nano::port_mapping::check_lost_or_old_mapping () else { protocol.external_address = boost::asio::ip::address_v4::any (); - node.logger.always_log (boost::str (boost::format ("UPNP_GetExternalIPAddress failed %1%: %2%") % verify_port_mapping_error_l % strupnperror (verify_port_mapping_error_l))); - } - if (node.config.logging.upnp_details_logging ()) - { - node.logger.always_log (boost::str (boost::format ("UPnP %1% mapping verification response: %2%, external ip response: %3%, external ip: %4%, internal ip: %5%, remaining lease: %6%") % protocol.name % verify_port_mapping_error_l % external_ip_error_l % external_address_l.data () % address.to_string () % remaining_mapping_duration_l.data ())); + + node.nlogger.warn (nano::log::type::upnp, "UPnP get external ip address failed: {} ({})", + external_ip_error_l, + strupnperror (external_ip_error_l)); } + + node.nlogger.debug (nano::log::type::upnp, "UPnP {} mapping verification response: {}, external ip response: {}, external ip: {}, internal ip: {}, remaining lease: {}", + protocol.name, + verify_port_mapping_error_l, + external_ip_error_l, + external_address_l.data (), + address.to_string (), + remaining_mapping_duration_l.data ()); } return result_l; } @@ -194,15 +219,14 @@ void nano::port_mapping::check_mapping_loop () } else { - node.logger.always_log (boost::str (boost::format ("UPnP No need to refresh the mapping"))); + node.nlogger.info (nano::log::type::upnp, "UPnP No need to refresh the mapping"); } } else { - if (check_count < 10 || node.config.logging.upnp_details_logging ()) - { - node.logger.always_log (boost::str (boost::format ("UPnP No IGD devices found"))); - } + // Bump logging level periodically + node.nlogger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, + nano::log::type::upnp, "UPnP No IGD devices found"); } // Check for new devices or after health_check_period @@ -225,11 +249,17 @@ void nano::port_mapping::stop () auto delete_error_l (UPNP_DeletePortMapping (upnp.urls.controlURL, upnp.data.first.servicetype, std::to_string (protocol.external_port).c_str (), protocol.name, address.to_string ().c_str ())); if (delete_error_l) { - node.logger.always_log (boost::str (boost::format ("UPnP shutdown %1% port mapping response: %2%") % protocol.name % delete_error_l)); + node.nlogger.warn (nano::log::type::upnp, "UPnP shutdown {} port mapping failed: {} ({})", + protocol.name, + delete_error_l, + strupnperror (delete_error_l)); } else { - node.logger.always_log (boost::str (boost::format ("UPnP shutdown %1% port mapping successful: %2%:%3%") % protocol.name % protocol.external_address % protocol.external_port)); + node.nlogger.info (nano::log::type::upnp, "UPnP shutdown {} port mapping successful: {}:{}", + protocol.name, + protocol.external_address.to_string (), + protocol.external_port); } } } diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 0d637b1483..3c8b251896 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -45,20 +45,18 @@ void nano::rep_crawler::validate () if (channel->get_type () == nano::transport::transport_type::loopback) { - if (node.config.logging.rep_crawler_logging ()) - { - node.logger.try_log (boost::str (boost::format ("rep_crawler ignoring vote from loopback channel %1%") % channel->to_string ())); - } + node.nlogger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); + continue; } nano::uint128_t rep_weight = node.ledger.weight (vote->account); if (rep_weight < minimum) { - if (node.config.logging.rep_crawler_logging ()) - { - node.logger.try_log (boost::str (boost::format ("rep_crawler ignoring vote from account %1% with too little voting weight %2%") % vote->account.to_account () % rep_weight)); - } + node.nlogger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", + vote->account.to_account (), + nano::util::to_str (rep_weight)); + continue; } @@ -95,12 +93,11 @@ void nano::rep_crawler::validate () if (inserted) { - node.logger.try_log (boost::str (boost::format ("Found representative %1% at %2%") % vote->account.to_account () % channel->to_string ())); + node.nlogger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); } - if (updated) { - node.logger.try_log (boost::str (boost::format ("Updated representative %1% at %2% (was at: %3%)") % vote->account.to_account () % channel->to_string () % prev_channel->to_string ())); + node.nlogger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); } } } diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 39037b734b..4649726786 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -22,23 +22,20 @@ void nano::transport::channel::send (nano::message & message_a, std::function #include +#include + nano::transport::message_deserializer::message_deserializer (nano::network_constants const & network_constants_a, nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, read_query read_op) : read_buffer{ std::make_shared> () }, @@ -380,8 +382,10 @@ std::unique_ptr nano::transport::message_deserializer::deser return {}; } -nano::stat::detail nano::transport::message_deserializer::to_stat_detail (parse_status status) +nano::stat::detail nano::to_stat_detail (nano::transport::message_deserializer::parse_status status) { + using parse_status = nano::transport::message_deserializer::parse_status; + // Keep additional `break` for readability switch (status) { @@ -449,74 +453,7 @@ nano::stat::detail nano::transport::message_deserializer::to_stat_detail (parse_ return {}; } -std::string nano::transport::message_deserializer::to_string (parse_status status) +std::string_view nano::to_string (nano::transport::message_deserializer::parse_status status) { - // Keep additional `break` for readability - switch (status) - { - case parse_status::none: - return "none"; - break; - case parse_status::success: - return "success"; - break; - case parse_status::insufficient_work: - return "insufficient_work"; - break; - case parse_status::invalid_header: - return "invalid_header"; - break; - case parse_status::invalid_message_type: - return "invalid_message_type"; - break; - case parse_status::invalid_keepalive_message: - return "invalid_keepalive_message"; - break; - case parse_status::invalid_publish_message: - return "invalid_publish_message"; - break; - case parse_status::invalid_confirm_req_message: - return "invalid_confirm_req_message"; - break; - case parse_status::invalid_confirm_ack_message: - return "invalid_confirm_ack_message"; - break; - case parse_status::invalid_node_id_handshake_message: - return "invalid_node_id_handshake_message"; - break; - case parse_status::invalid_telemetry_req_message: - return "invalid_telemetry_req_message"; - break; - case parse_status::invalid_telemetry_ack_message: - return "invalid_telemetry_ack_message"; - break; - case parse_status::invalid_bulk_pull_message: - return "invalid_bulk_pull_message"; - break; - case parse_status::invalid_bulk_pull_account_message: - return "invalid_bulk_pull_account_message"; - break; - case parse_status::invalid_frontier_req_message: - return "invalid_frontier_req_message"; - break; - case parse_status::invalid_asc_pull_req_message: - return "invalid_asc_pull_req_message"; - break; - case parse_status::invalid_asc_pull_ack_message: - return "invalid_asc_pull_ack_message"; - break; - case parse_status::invalid_network: - return "invalid_network"; - break; - case parse_status::outdated_version: - return "outdated_version"; - break; - case parse_status::duplicate_publish_message: - return "duplicate_publish_message"; - break; - case parse_status::message_size_too_big: - return "message_size_too_big"; - break; - } - return "n/a"; + return magic_enum::enum_name (status); } diff --git a/nano/node/transport/message_deserializer.hpp b/nano/node/transport/message_deserializer.hpp index 0a85454e51..9a2fbc21c6 100644 --- a/nano/node/transport/message_deserializer.hpp +++ b/nano/node/transport/message_deserializer.hpp @@ -89,11 +89,9 @@ namespace transport nano::block_uniquer & block_uniquer_m; nano::vote_uniquer & vote_uniquer_m; read_query read_op; - - public: - static stat::detail to_stat_detail (parse_status); - static std::string to_string (parse_status); }; - } + +nano::stat::detail to_stat_detail (nano::transport::message_deserializer::parse_status); +std::string_view to_string (nano::transport::message_deserializer::parse_status); } diff --git a/nano/node/transport/socket.cpp b/nano/node/transport/socket.cpp index 21fbc4de44..11b2957f22 100644 --- a/nano/node/transport/socket.cpp +++ b/nano/node/transport/socket.cpp @@ -54,6 +54,7 @@ void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint this_l->tcp_socket.async_connect (endpoint_a, boost::asio::bind_executor (this_l->strand, [this_l, callback = std::move (callback_a), endpoint_a] (boost::system::error_code const & ec) { + this_l->remote = endpoint_a; if (ec) { this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_connect_error, nano::stat::dir::in); @@ -62,9 +63,13 @@ void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint else { this_l->set_last_completion (); + { + // Best effort attempt to get endpoint address + boost::system::error_code ec; + this_l->local = this_l->tcp_socket.local_endpoint (ec); + } + this_l->node.observers.socket_connected.notify (*this_l); } - this_l->remote = endpoint_a; - this_l->node.observers.socket_connected.notify (*this_l); callback (ec); })); } @@ -241,23 +246,22 @@ void nano::transport::socket::ongoing_checkup () if (this_l->endpoint_type () == endpoint_type_t::server && (now - this_l->last_receive_time_or_init) > static_cast (this_l->silent_connection_tolerance_time.count ())) { this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_silent_connection_drop, nano::stat::dir::in); + condition_to_disconnect = true; } // if there is no activity for timeout seconds then disconnect if ((now - this_l->last_completion_time_or_init) > this_l->timeout) { - this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_io_timeout_drop, - this_l->endpoint_type () == endpoint_type_t::server ? nano::stat::dir::in : nano::stat::dir::out); + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_io_timeout_drop, this_l->endpoint_type () == endpoint_type_t::server ? nano::stat::dir::in : nano::stat::dir::out); + condition_to_disconnect = true; } if (condition_to_disconnect) { - if (this_l->node.config.logging.network_timeout_logging ()) - { - this_l->node.logger.try_log (boost::str (boost::format ("Disconnecting from %1% due to timeout") % this_l->remote)); - } + this_l->node.nlogger.debug (nano::log::type::tcp_server, "Closing socket due to timeout ({})", nano::util::to_str (this_l->remote)); + this_l->timed_out = true; this_l->close (); } @@ -330,19 +334,21 @@ void nano::transport::socket::close_internal () if (ec) { - node.logger.try_log ("Failed to close socket gracefully: ", ec.message ()); - node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::error_socket_close); + node.stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close); + node.nlogger.error (nano::log::type::socket, "Failed to close socket gracefully: {} ({})", ec.message (), nano::util::to_str (remote)); } } nano::tcp_endpoint nano::transport::socket::remote_endpoint () const { + // Using cached value to avoid calling tcp_socket.remote_endpoint() which may be invalid (throw) after closing the socket return remote; } nano::tcp_endpoint nano::transport::socket::local_endpoint () const { - return tcp_socket.local_endpoint (); + // Using cached value to avoid calling tcp_socket.local_endpoint() which may be invalid (throw) after closing the socket + return local; } /* diff --git a/nano/node/transport/socket.hpp b/nano/node/transport/socket.hpp index b2593b1ba2..0ac01400fc 100644 --- a/nano/node/transport/socket.hpp +++ b/nano/node/transport/socket.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include @@ -157,6 +158,7 @@ class socket final : public std::enable_shared_from_thisnetwork.prepare_handshake_query (endpoint_a); nano::node_id_handshake message{ node_l->network_params.network, query }; - if (node_l->config.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Node ID handshake request sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (query ? query->cookie.to_string () : "not set"))); - } + node_l->nlogger.debug (nano::log::type::tcp, "Handshake sent to: {} (query: {})", + nano::util::to_str (endpoint_a), + (query ? query->cookie.to_string () : "")); channel->set_endpoint (); std::shared_ptr> receive_buffer (std::make_shared> ()); @@ -572,30 +571,25 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a } else { + node_l->nlogger.debug (nano::log::type::tcp, "Error sending handshake to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + if (auto socket_l = channel->socket.lock ()) { socket_l->close (); } - if (node_l->config.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); - } } } }); } else { - if (node_l->config.logging.network_logging ()) + if (ec) { - if (ec) - { - node_l->logger.try_log (boost::str (boost::format ("Error connecting to %1%: %2%") % endpoint_a % ec.message ())); - } - else - { - node_l->logger.try_log (boost::str (boost::format ("Error connecting to %1%") % endpoint_a)); - } + node_l->nlogger.debug (nano::log::type::tcp, "Error connecting to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + } + else + { + node_l->nlogger.debug (nano::log::type::tcp, "Error connecting to: {}", nano::util::to_str (endpoint_a)); } } } @@ -633,10 +627,8 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrconfig.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Error reading node_id_handshake from %1%: %2%") % endpoint_a % ec.message ())); - } + node_l->nlogger.debug (nano::log::type::tcp, "Error reading handshake from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + cleanup_node_id_handshake_socket (endpoint_a); return; } @@ -646,10 +638,8 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrtype () != nano::message_type::node_id_handshake) { - if (node_l->config.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Error reading node_id_handshake message header from %1%") % endpoint_a)); - } + node_l->nlogger.debug (nano::log::type::tcp, "Error reading handshake header from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + cleanup_node_id_handshake_socket (endpoint_a); return; } @@ -678,10 +668,8 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrconfig.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Error reading node_id_handshake from %1%") % endpoint_a)); - } + node_l->nlogger.debug (nano::log::type::tcp, "Error reading handshake payload from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + cleanup_node_id_handshake_socket (endpoint_a); return; } @@ -714,10 +702,9 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnetwork.prepare_handshake_response (*handshake.query, handshake.is_v2 ()); nano::node_id_handshake handshake_response (node_l->network_params.network, std::nullopt, response); - if (node_l->config.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % handshake.query->cookie.to_string ())); - } + node_l->nlogger.debug (nano::log::type::tcp, "Handshake response sent to {} (query: {})", + nano::util::to_str (endpoint_a), + handshake.query->cookie.to_string ()); channel_a->send (handshake_response, [node_w, channel_a, endpoint_a, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, std::size_t size_a) { auto node_l = node_w.lock (); @@ -727,10 +714,8 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrconfig.logging.network_node_id_handshake_logging ()) - { - node_l->logger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); - } + node_l->nlogger.debug (nano::log::type::tcp, "Error sending handshake response to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + cleanup_node_id_handshake_socket (endpoint_a); return; } diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 57222dc365..3b920c1c34 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -56,7 +56,7 @@ void nano::transport::tcp_listener::start (std::functionacceptor.is_open ()) { - this_l->node.logger.always_log ("Network: Acceptor is not open"); + this_l->node.nlogger.error (nano::log::type::tcp_listener, "Acceptor is not open"); return; } @@ -138,20 +138,18 @@ void nano::transport::tcp_listener::on_connection (std::functionconnections_per_address.size () >= this_l->max_inbound_connections) { - this_l->node.logger.try_log ("Network: max_inbound_connections reached, unable to open new connection"); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); + this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections reached ({}), unable to open new connection", this_l->connections_per_address.size ()); + this_l->on_connection_requeue_delayed (std::move (cbk)); return; } if (this_l->limit_reached_for_incoming_ip_connections (new_connection)) { - auto const remote_ip_address = new_connection->remote_endpoint ().address (); - auto const log_message = boost::str ( - boost::format ("Network: max connections per IP (max_peers_per_ip) was reached for %1%, unable to open new connection") - % remote_ip_address.to_string ()); - this_l->node.logger.try_log (log_message); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::in); + this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections per IP reached ({}), unable to open new connection", new_connection->remote_endpoint ().address ().to_string ()); + this_l->on_connection_requeue_delayed (std::move (cbk)); return; } @@ -161,12 +159,12 @@ void nano::transport::tcp_listener::on_connection (std::functionremote_endpoint ().address (); debug_assert (remote_ip_address.is_v6 ()); auto const remote_subnet = socket_functions::get_ipv6_subnet_address (remote_ip_address.to_v6 (), this_l->node.network_params.network.max_peers_per_subnetwork); - auto const log_message = boost::str ( - boost::format ("Network: max connections per subnetwork (max_peers_per_subnetwork) was reached for subnetwork %1% (remote IP: %2%), unable to open new connection") - % remote_subnet.canonical ().to_string () - % remote_ip_address.to_string ()); - this_l->node.logger.try_log (log_message); + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::in); + this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections per subnetwork reached (subnetwork: {}, ip: {}), unable to open new connection", + remote_subnet.canonical ().to_string (), + remote_ip_address.to_string ()); + this_l->on_connection_requeue_delayed (std::move (cbk)); return; } @@ -185,13 +183,13 @@ void nano::transport::tcp_listener::on_connection (std::functionon_connection (std::move (cbk)); return; } - this_l->node.logger.always_log ("Network: Stopping to accept connections"); + this_l->node.nlogger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); return; } // accept error - this_l->node.logger.try_log ("Network: Unable to accept connection: ", ec_a.message ()); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); + this_l->node.nlogger.error (nano::log::type::tcp_listener, "Unable to accept connection: {} ({})", ec_a.message (), new_connection->remote_endpoint ().address ().to_string ()); if (is_temporary_error (ec_a)) { @@ -208,7 +206,7 @@ void nano::transport::tcp_listener::on_connection (std::functionnode.logger.always_log ("Network: Stopping to accept connections"); + this_l->node.nlogger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); })); })); } @@ -250,10 +248,7 @@ void nano::transport::tcp_listener::accept_action (boost::system::error_code con else { node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_excluded); - if (node.config.logging.network_rejected_logging ()) - { - node.logger.try_log ("Rejected connection from excluded peer ", socket_a->remote_endpoint ()); - } + node.nlogger.debug (nano::log::type::tcp_server, "Rejected connection from excluded peer: {}", nano::util::to_str (socket_a->remote_endpoint ())); } } @@ -304,10 +299,8 @@ nano::transport::tcp_server::~tcp_server () { return; } - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Exiting incoming TCP/bootstrap server"); - } + + node->nlogger.debug (nano::log::type::tcp_server, "Exiting TCP server ({})", nano::util::to_str (remote_endpoint)); if (socket->type () == nano::transport::socket::type_t::bootstrap) { @@ -340,6 +333,12 @@ void nano::transport::tcp_server::start () remote_endpoint = socket->remote_endpoint (); debug_assert (remote_endpoint.port () != 0); } + + if (auto node_l = node.lock (); node_l) + { + node_l->nlogger.debug (nano::log::type::tcp_server, "Starting TCP server ({})", nano::util::to_str (remote_endpoint)); + } + receive_message (); } @@ -367,7 +366,12 @@ void nano::transport::tcp_server::receive_message () if (ec) { // IO error or critical error when deserializing message - node->stats.inc (nano::stat::type::error, nano::transport::message_deserializer::to_stat_detail (this_l->message_deserializer->status)); + node->stats.inc (nano::stat::type::error, nano::to_stat_detail (this_l->message_deserializer->status)); + node->nlogger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})", + ec.message (), + nano::to_string (this_l->message_deserializer->status), + nano::util::to_str (this_l->remote_endpoint)); + this_l->stop (); } else @@ -393,11 +397,19 @@ void nano::transport::tcp_server::received_message (std::unique_ptrstatus != transport::message_deserializer::parse_status::success); - node->stats.inc (nano::stat::type::error, nano::transport::message_deserializer::to_stat_detail (message_deserializer->status)); + + node->stats.inc (nano::stat::type::error, nano::to_stat_detail (message_deserializer->status)); if (message_deserializer->status == transport::message_deserializer::parse_status::duplicate_publish_message) { node->stats.inc (nano::stat::type::filter, nano::stat::detail::duplicate_publish); } + else + { + // Avoid too much noise about `duplicate_publish_message` errors + node->nlogger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})", + nano::to_string (message_deserializer->status), + nano::util::to_str (remote_endpoint)); + } } if (should_continue) @@ -448,6 +460,10 @@ bool nano::transport::tcp_server::process_message (std::unique_ptrnlogger.debug (nano::log::type::tcp_server, "Neither handshake nor bootstrap received when in handshake mode: {} ({})", + nano::to_string (message->header.type), + nano::util::to_str (remote_endpoint)); + return true; } } @@ -500,10 +516,8 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( } if (node->flags.disable_tcp_realtime) { - if (node->config.logging.network_node_id_handshake_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Disabled realtime TCP for handshake %1%") % server->remote_endpoint)); - } + node->nlogger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime TCP ({})", nano::util::to_str (server->remote_endpoint)); + // Stop invalid handshake server->stop (); return; @@ -511,10 +525,8 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( if (message.query && server->handshake_query_received) { - if (node->config.logging.network_node_id_handshake_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Detected multiple node_id_handshake query from %1%") % server->remote_endpoint)); - } + node->nlogger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", nano::util::to_str (server->remote_endpoint)); + // Stop invalid handshake server->stop (); return; @@ -522,10 +534,7 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( server->handshake_query_received = true; - if (node->config.logging.network_node_id_handshake_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Received node_id_handshake message from %1%") % server->remote_endpoint)); - } + node->nlogger.debug (nano::log::type::tcp_server, "Handshake query received ({})", nano::util::to_str (server->remote_endpoint)); if (message.query) { @@ -569,10 +578,8 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha } if (ec) { - if (node->config.logging.network_node_id_handshake_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % this_l->remote_endpoint % ec.message ())); - } + node->nlogger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), nano::util::to_str (this_l->remote_endpoint)); + // Stop invalid handshake this_l->stop (); } @@ -692,11 +699,6 @@ void nano::transport::tcp_server::bootstrap_message_visitor::bulk_pull (const na return; } - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Received bulk pull for %1% down to %2%, maximum of %3% from %4%") % message.start.to_string () % message.end.to_string () % message.count % server->remote_endpoint)); - } - node->bootstrap_workers.push_task ([server = server, message = message] () { // TODO: Add completion callback to bulk pull server // TODO: There should be no need to re-copy message as unique pointer, refactor those bulk/frontier pull/push servers @@ -719,11 +721,6 @@ void nano::transport::tcp_server::bootstrap_message_visitor::bulk_pull_account ( return; } - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Received bulk pull account for %1% with a minimum amount of %2%") % message.account.to_account () % nano::amount (message.minimum_amount).format_balance (nano::Mxrb_ratio, 10, true))); - } - node->bootstrap_workers.push_task ([server = server, message = message] () { // TODO: Add completion callback to bulk pull server // TODO: There should be no need to re-copy message as unique pointer, refactor those bulk/frontier pull/push servers @@ -757,10 +754,6 @@ void nano::transport::tcp_server::bootstrap_message_visitor::frontier_req (const { return; } - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log (boost::str (boost::format ("Received frontier request for %1% with age %2%") % message.start.to_string () % message.age)); - } node->bootstrap_workers.push_task ([server = server, message = message] () { // TODO: There should be no need to re-copy message as unique pointer, refactor those bulk/frontier pull/push servers @@ -782,10 +775,8 @@ void nano::transport::tcp_server::timeout () } if (socket->has_timed_out ()) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Closing incoming tcp / bootstrap server by timeout"); - } + node->nlogger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", nano::util::to_str (remote_endpoint)); + { nano::lock_guard lock{ node->tcp_listener->mutex }; node->tcp_listener->connections.erase (this); @@ -820,6 +811,9 @@ bool nano::transport::tcp_server::to_bootstrap_connection () ++node->tcp_listener->bootstrap_count; socket->type_set (nano::transport::socket::type_t::bootstrap); + + node->nlogger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", nano::util::to_str (remote_endpoint)); + return true; } @@ -835,6 +829,9 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const & remote_node_id = node_id; ++node->tcp_listener->realtime_count; socket->type_set (nano::transport::socket::type_t::realtime); + + node->nlogger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", nano::util::to_str (remote_endpoint)); + return true; } return false; diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 76a32d59df..01d169ab04 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -15,12 +15,12 @@ #include using namespace std::chrono_literals; -nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger_mt & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : +nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::nlogger & nlogger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : active (active_a), observers (observers_a), stats (stats_a), config (config_a), - logger (logger_a), + nlogger (nlogger_a), online_reps (online_reps_a), rep_crawler (rep_crawler_a), ledger (ledger_a), @@ -76,8 +76,12 @@ void nano::vote_processor::process_loop () if (log_this_iteration && elapsed.stop () > std::chrono::milliseconds (100)) { - logger.try_log (boost::str (boost::format ("Processed %1% votes in %2% milliseconds (rate of %3% votes per second)") % votes_l.size () % elapsed.value ().count () % ((votes_l.size () * 1000ULL) / elapsed.value ().count ()))); + nlogger.debug (nano::log::type::vote_processor, "Processed {} votes in {} milliseconds (rate of {} votes per second)", + votes_l.size (), + elapsed.value ().count (), + ((votes_l.size () * 1000ULL) / elapsed.value ().count ())); } + lock.lock (); } else @@ -168,10 +172,7 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr stats.inc (nano::stat::type::vote, nano::stat::detail::vote_indeterminate); break; } - if (config.logging.vote_logging ()) - { - logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% duration %3%ms block(s): %4% status: %5%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp ()) % std::to_string (vote_a->duration ().count ()) % vote_a->hashes_string () % status)); - } + return result; } @@ -197,7 +198,7 @@ void nano::vote_processor::flush () }); if (!success) { - logger.always_log ("WARNING: vote_processor::flush timeout while waiting for flush"); + nlogger.error (nano::log::type::vote_processor, "Flush timeout"); debug_assert (false && "vote_processor::flush timeout while waiting for flush"); } } diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index 4ee3c6f0ea..6ae37d16b2 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -20,7 +20,7 @@ namespace store class node_observers; class stats; class node_config; -class logger_mt; +class nlogger; class online_reps; class rep_crawler; class ledger; @@ -36,7 +36,7 @@ namespace transport class vote_processor final { public: - vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger_mt & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); + vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::nlogger &, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); /** Returns false if the vote was processed */ bool vote (std::shared_ptr const &, std::shared_ptr const &); @@ -60,7 +60,7 @@ class vote_processor final nano::node_observers & observers; nano::stats & stats; nano::node_config & config; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::online_reps & online_reps; nano::rep_crawler & rep_crawler; nano::ledger & ledger; diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index f2e05c6cd2..6ce77661ed 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -699,16 +699,17 @@ bool nano::wallet::enter_password (store::transaction const & transaction_a, std auto result (store.attempt_password (transaction_a, password_a)); if (!result) { + wallets.node.nlogger.info (nano::log::type::wallet, "Wallet unlocked"); + auto this_l = shared_from_this (); wallets.node.wallets.queue_wallet_action (nano::wallets::high_priority, this_l, [this_l] (nano::wallet & wallet) { // Wallets must survive node lifetime this_l->search_receivable (this_l->wallets.tx_begin_read ()); }); - wallets.node.logger.try_log ("Wallet unlocked"); } else { - wallets.node.logger.try_log ("Invalid password, wallet locked"); + wallets.node.nlogger.warn (nano::log::type::wallet, "Invalid password, wallet locked"); } lock_observer (result, password_a.empty ()); return result; @@ -865,7 +866,7 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons } else { - wallets.node.logger.try_log ("Unable to receive, wallet locked"); + wallets.node.nlogger.warn (nano::log::type::wallet, "Unable to receive, wallet locked"); } } else @@ -880,8 +881,8 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons } else { - wallets.node.logger.try_log (boost::str (boost::format ("Not receiving block %1% due to minimum receive threshold") % send_hash_a.to_string ())); // Someone sent us something below the threshold of receiving + wallets.node.nlogger.warn (nano::log::type::wallet, "Not receiving block {} due to minimum receive threshold", send_hash_a.to_string ()); } if (block != nullptr) { @@ -1043,7 +1044,10 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a auto required_difficulty{ wallets.node.network_params.work.threshold (block_a->work_version (), details_a) }; if (wallets.node.network_params.work.difficulty (*block_a) < required_difficulty) { - wallets.node.logger.try_log (boost::str (boost::format ("Cached or provided work for block %1% account %2% is invalid, regenerating") % block_a->hash ().to_string () % account_a.to_account ())); + wallets.node.nlogger.info (nano::log::type::wallet, "Cached or provided work for block {} account {} is invalid, regenerating...", + block_a->hash ().to_string (), + account_a.to_account ()); + debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ())); error = !wallets.node.work_generate_blocking (*block_a, required_difficulty).is_initialized (); } @@ -1139,7 +1143,7 @@ void nano::wallet::work_update (store::transaction const & transaction_a, nano:: } else { - wallets.node.logger.try_log ("Cached work no longer valid, discarding"); + wallets.node.nlogger.warn (nano::log::type::wallet, "Cached work no longer valid, discarding"); } } @@ -1168,7 +1172,8 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact auto result (!store.valid_password (wallet_transaction_a)); if (!result) { - wallets.node.logger.try_log ("Beginning receivable block search"); + wallets.node.nlogger.info (nano::log::type::wallet, "Beginning receivable block search"); + for (auto i (store.begin (wallet_transaction_a)), n (store.end ()); i != n; ++i) { auto block_transaction (wallets.node.store.tx_begin_read ()); @@ -1184,7 +1189,8 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact auto amount (pending.amount.number ()); if (wallets.node.config.receive_minimum.number () <= amount) { - wallets.node.logger.try_log (boost::str (boost::format ("Found a receivable block %1% for account %2%") % hash.to_string () % pending.source.to_account ())); + wallets.node.nlogger.info (nano::log::type::wallet, "Found a receivable block {} for account {}", hash.to_string (), pending.source.to_account ()); + if (wallets.node.ledger.block_confirmed (block_transaction, hash)) { auto representative = store.representative (wallet_transaction_a); @@ -1204,11 +1210,12 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact } } } - wallets.node.logger.try_log ("Receivable block search phase completed"); + + wallets.node.nlogger.info (nano::log::type::wallet, "Receivable block search phase complete"); } else { - wallets.node.logger.try_log ("Stopping search, wallet is locked"); + wallets.node.nlogger.warn (nano::log::type::wallet, "Stopping search, wallet is locked"); } return result; } @@ -1300,7 +1307,7 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::r } else if (!wallets.node.stopped) { - wallets.node.logger.try_log (boost::str (boost::format ("Could not precache work for root %1% due to work generation failure") % root_a.to_string ())); + wallets.node.nlogger.warn (nano::log::type::wallet, "Could not precache work for root {} due to work generation failure", root_a.to_string ()); } } } @@ -1388,7 +1395,7 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) : char const * store_path; mdb_env_get_path (env, &store_path); std::filesystem::path const path (store_path); - nano::store::lmdb::component::create_backup_file (env, path, node_a.logger); + nano::store::lmdb::component::create_backup_file (env, path, node_a.nlogger); } for (auto & item : items) { @@ -1556,11 +1563,13 @@ void nano::wallets::foreach_representative (std::functionfirst.to_string ())); + + node.nlogger.warn (nano::log::type::wallet, "Representative locked inside wallet: {}", i->first.to_string ()); } } } diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index fd436c6b14..a58a2a5247 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -14,14 +15,15 @@ #include #include -nano::websocket::confirmation_options::confirmation_options (nano::wallets & wallets_a) : - wallets (wallets_a) +nano::websocket::confirmation_options::confirmation_options (nano::wallets & wallets_a, nano::nlogger & nlogger_a) : + wallets (wallets_a), + nlogger (nlogger_a) { } -nano::websocket::confirmation_options::confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::logger_mt & logger_a) : +nano::websocket::confirmation_options::confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::nlogger & nlogger_a) : wallets (wallets_a), - logger (logger_a) + nlogger (nlogger_a) { // Non-account filtering options include_block = options_a.get ("include_block", true); @@ -62,7 +64,7 @@ nano::websocket::confirmation_options::confirmation_options (boost::property_tre if (!include_block) { - logger_a.always_log ("Websocket: Filtering option \"all_local_accounts\" requires that \"include_block\" is set to true to be effective"); + nlogger.warn (nano::log::type::websocket, "Filtering option \"all_local_accounts\" requires that \"include_block\" is set to true to be effective"); } } auto accounts_l (options_a.get_child_optional ("accounts")); @@ -79,13 +81,13 @@ nano::websocket::confirmation_options::confirmation_options (boost::property_tre } else { - logger_a.always_log ("Websocket: invalid account provided for filtering blocks: ", account_l.second.data ()); + nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); } } if (!include_block) { - logger_a.always_log ("Websocket: Filtering option \"accounts\" requires that \"include_block\" is set to true to be effective"); + nlogger.warn (nano::log::type::websocket, "Filtering option \"accounts\" requires that \"include_block\" is set to true to be effective"); } } check_filter_empty (); @@ -158,9 +160,9 @@ bool nano::websocket::confirmation_options::update (boost::property_tree::ptree this->accounts.erase (encoded_l); } } - else if (this->logger.is_initialized ()) + else { - this->logger->always_log ("Websocket: invalid account provided for filtering blocks: ", account_l.second.data ()); + nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); } } }; @@ -186,13 +188,13 @@ bool nano::websocket::confirmation_options::update (boost::property_tree::ptree void nano::websocket::confirmation_options::check_filter_empty () const { // Warn the user if the options resulted in an empty filter - if (logger.is_initialized () && has_account_filtering_options && !all_local_accounts && accounts.empty ()) + if (has_account_filtering_options && !all_local_accounts && accounts.empty ()) { - logger->always_log ("Websocket: provided options resulted in an empty block confirmation filter"); + nlogger.warn (nano::log::type::websocket, "Provided options resulted in an empty account confirmation filter"); } } -nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & options_a, nano::logger_mt & logger_a) +nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & options_a, nano::nlogger & nlogger) { include_replays = options_a.get ("include_replays", false); include_indeterminate = options_a.get ("include_indeterminate", false); @@ -209,13 +211,13 @@ nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & } else { - logger_a.always_log ("Websocket: invalid account given to filter votes: ", representative_l.second.data ()); + nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering votes: ", representative_l.second.data ()); } } // Warn the user if the option will be ignored if (representatives.empty ()) { - logger_a.always_log ("Websocket: account filter for votes is empty, no messages will be filtered"); + nlogger.warn (nano::log::type::websocket, "Account filter for votes is empty, no messages will be filtered"); } } } @@ -240,15 +242,25 @@ bool nano::websocket::vote_options::should_filter (nano::websocket::message cons nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a, boost::asio::ssl::context & ctx_a) : ws_listener (listener_a), ws (std::move (socket_a), ctx_a) { - ws_listener.get_logger ().try_log ("Websocket: secure session started"); } #endif -nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a) : - ws_listener (listener_a), ws (std::move (socket_a)) +nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a, nano::nlogger & nlogger_a) : + ws_listener (listener_a), + ws (std::move (socket_a)), + nlogger (nlogger_a) { - ws_listener.get_logger ().try_log ("Websocket: session started"); + { + // Best effort attempt to get endpoint addresses + boost::system::error_code ec; + remote = ws.get_socket ().remote_endpoint (ec); + debug_assert (!ec); + local = ws.get_socket ().local_endpoint (ec); + debug_assert (!ec); + } + + nlogger.info (nano::log::type::websocket, "Session started ({})", nano::util::to_str (remote)); } nano::websocket::session::~session () @@ -273,14 +285,14 @@ void nano::websocket::session::handshake () } else { - this_l->ws_listener.get_logger ().always_log ("Websocket: handshake failed: ", ec.message ()); + this_l->nlogger.error (nano::log::type::websocket, "Handshake failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); } }); } void nano::websocket::session::close () { - ws_listener.get_logger ().try_log ("Websocket: session closing"); + nlogger.info (nano::log::type::websocket, "Session closing ({})", nano::util::to_str (remote)); auto this_l (shared_from_this ()); boost::asio::dispatch (ws.get_strand (), @@ -356,12 +368,12 @@ void nano::websocket::session::read () } catch (boost::property_tree::json_parser::json_parser_error const & ex) { - this_l->ws_listener.get_logger ().try_log ("Websocket: json parsing failed: ", ex.what ()); + this_l->nlogger.error (nano::log::type::websocket, "JSON parsing failed: {} ({})", ex.what (), nano::util::to_str (this_l->remote)); } } else if (ec != boost::asio::error::eof) { - this_l->ws_listener.get_logger ().try_log ("Websocket: read failed: ", ec.message ()); + this_l->nlogger.error (nano::log::type::websocket, "Read failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); } }); }); @@ -483,11 +495,11 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const std::unique_ptr options_l{ nullptr }; if (options_text_l && topic_l == nano::websocket::topic::confirmation) { - options_l = std::make_unique (options_text_l.get (), ws_listener.get_wallets (), ws_listener.get_logger ()); + options_l = std::make_unique (options_text_l.get (), ws_listener.get_wallets (), nlogger); } else if (options_text_l && topic_l == nano::websocket::topic::vote) { - options_l = std::make_unique (options_text_l.get (), ws_listener.get_logger ()); + options_l = std::make_unique (options_text_l.get (), nlogger); } else { @@ -496,13 +508,15 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const auto existing (subscriptions.find (topic_l)); if (existing != subscriptions.end ()) { + nlogger.info (nano::log::type::websocket, "Updated subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + existing->second = std::move (options_l); - ws_listener.get_logger ().always_log ("Websocket: updated subscription to topic: ", from_topic (topic_l)); } else { + nlogger.info (nano::log::type::websocket, "New subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + subscriptions.emplace (topic_l, std::move (options_l)); - ws_listener.get_logger ().always_log ("Websocket: new subscription to topic: ", from_topic (topic_l)); ws_listener.increase_subscriber_count (topic_l); } action_succeeded = true; @@ -525,7 +539,8 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const nano::lock_guard lk (subscriptions_mutex); if (subscriptions.erase (topic_l)) { - ws_listener.get_logger ().always_log ("Websocket: removed subscription to topic: ", from_topic (topic_l)); + nlogger.info (nano::log::type::websocket, "Removed subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + ws_listener.decrease_subscriber_count (topic_l); } action_succeeded = true; @@ -559,9 +574,9 @@ void nano::websocket::listener::stop () sessions.clear (); } -nano::websocket::listener::listener (std::shared_ptr const & tls_config_a, nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : +nano::websocket::listener::listener (std::shared_ptr const & tls_config_a, nano::nlogger & nlogger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : tls_config (tls_config_a), - logger (logger_a), + nlogger (nlogger_a), wallets (wallets_a), acceptor (io_ctx_a), socket (io_ctx_a) @@ -579,7 +594,7 @@ nano::websocket::listener::listener (std::shared_ptr const & t } catch (std::exception const & ex) { - logger.always_log ("Websocket: listen failed: ", ex.what ()); + nlogger.error (nano::log::type::websocket, "Listen failed: {}", ex.what ()); } } @@ -604,7 +619,7 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec) { if (ec) { - logger.always_log ("Websocket: accept failed: ", ec.message ()); + nlogger.error (nano::log::type::websocket, "Accept failed: {}", ec.message ()); } else { @@ -618,7 +633,7 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec) } else { - session = std::make_shared (*this, std::move (socket)); + session = std::make_shared (*this, std::move (socket), nlogger); } sessions_mutex.lock (); @@ -650,7 +665,7 @@ void nano::websocket::listener::broadcast_confirmation (std::shared_ptrsubscriptions.find (nano::websocket::topic::confirmation)); if (subscription != session_ptr->subscriptions.end ()) { - nano::websocket::confirmation_options default_options (wallets); + nano::websocket::confirmation_options default_options (wallets, nlogger); auto conf_options (dynamic_cast (subscription->second.get ())); if (conf_options == nullptr) { @@ -967,13 +982,13 @@ std::string nano::websocket::message::to_string () const * websocket_server */ -nano::websocket_server::websocket_server (nano::websocket::config & config_a, nano::node_observers & observers_a, nano::wallets & wallets_a, nano::ledger & ledger_a, boost::asio::io_context & io_ctx_a, nano::logger_mt & logger_a) : +nano::websocket_server::websocket_server (nano::websocket::config & config_a, nano::node_observers & observers_a, nano::wallets & wallets_a, nano::ledger & ledger_a, boost::asio::io_context & io_ctx_a, nano::nlogger & nlogger_a) : config{ config_a }, observers{ observers_a }, wallets{ wallets_a }, ledger{ ledger_a }, io_ctx{ io_ctx_a }, - logger{ logger_a } + nlogger{ nlogger_a } { if (!config.enabled) { @@ -981,7 +996,7 @@ nano::websocket_server::websocket_server (nano::websocket::config & config_a, na } auto endpoint = nano::tcp_endpoint{ boost::asio::ip::make_address_v6 (config.address), config.port }; - server = std::make_shared (config.tls_config, logger, wallets, io_ctx, endpoint); + server = std::make_shared (config.tls_config, nlogger, wallets, io_ctx, endpoint); observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { debug_assert (status_a.type != nano::election_status_type::ongoing); diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 9d197dcfb6..84fdf60c8d 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -21,7 +21,7 @@ namespace nano { class wallets; -class logger_mt; +class nlogger; class vote; class election_status; class telemetry_data; @@ -142,8 +142,8 @@ namespace websocket class confirmation_options final : public options { public: - confirmation_options (nano::wallets & wallets_a); - confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::logger_mt & logger_a); + confirmation_options (nano::wallets & wallets_a, nano::nlogger &); + confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::nlogger &); /** * Checks if a message should be filtered for given block confirmation options. @@ -195,7 +195,8 @@ namespace websocket void check_filter_empty () const; nano::wallets & wallets; - boost::optional logger; + nano::nlogger & nlogger; + bool include_election_info{ false }; bool include_election_info_with_votes{ false }; bool include_sideband_info{ false }; @@ -214,7 +215,7 @@ namespace websocket class vote_options final : public options { public: - vote_options (boost::property_tree::ptree const & options_a, nano::logger_mt & logger_a); + vote_options (boost::property_tree::ptree const & options_a, nano::nlogger &); /** * Checks if a message should be filtered for given vote received options. @@ -240,7 +241,7 @@ namespace websocket explicit session (nano::websocket::listener & listener_a, socket_type socket_a, boost::asio::ssl::context & ctx_a); #endif /** Constructor that takes ownership over \p socket_a */ - explicit session (nano::websocket::listener & listener_a, socket_type socket_a); + explicit session (nano::websocket::listener & listener_a, socket_type socket_a, nano::nlogger &); ~session (); @@ -261,11 +262,17 @@ namespace websocket nano::websocket::listener & ws_listener; /** Websocket stream, supporting both plain and tls connections */ nano::websocket::stream ws; + nano::nlogger & nlogger; + /** Buffer for received messages */ boost::beast::multi_buffer read_buffer; /** Outgoing messages. The send queue is protected by accessing it only through the strand */ std::deque send_queue; + /** Cache remote & local endpoints to make them available after the socket is closed */ + socket_type::endpoint_type remote; + socket_type::endpoint_type local; + /** Hash functor for topic enums */ struct topic_hash { @@ -291,7 +298,7 @@ namespace websocket class listener final : public std::enable_shared_from_this { public: - listener (std::shared_ptr const & tls_config_a, nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); + listener (std::shared_ptr const & tls_config_a, nano::nlogger &, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); /** Start accepting connections */ void run (); @@ -307,11 +314,6 @@ namespace websocket /** Broadcast \p message to all session subscribing to the message topic. */ void broadcast (nano::websocket::message message_a); - nano::logger_mt & get_logger () const - { - return logger; - } - std::uint16_t listening_port () { return acceptor.local_endpoint ().port (); @@ -346,7 +348,7 @@ namespace websocket void decrease_subscriber_count (nano::websocket::topic const & topic_a); std::shared_ptr tls_config; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::wallets & wallets; boost::asio::ip::tcp::acceptor acceptor; socket_type socket; @@ -363,7 +365,7 @@ namespace websocket class websocket_server { public: - websocket_server (nano::websocket::config &, nano::node_observers &, nano::wallets &, nano::ledger &, boost::asio::io_context &, nano::logger_mt &); + websocket_server (nano::websocket::config &, nano::node_observers &, nano::wallets &, nano::ledger &, boost::asio::io_context &, nano::nlogger &); void start (); void stop (); @@ -374,7 +376,7 @@ class websocket_server nano::wallets & wallets; nano::ledger & ledger; boost::asio::io_context & io_ctx; - nano::logger_mt & logger; + nano::nlogger & nlogger; public: // TODO: Encapsulate, this is public just because existing code needs it diff --git a/nano/node/websocket_stream.cpp b/nano/node/websocket_stream.cpp index 74d5eaf8a3..d680e999d2 100644 --- a/nano/node/websocket_stream.cpp +++ b/nano/node/websocket_stream.cpp @@ -67,6 +67,11 @@ class stream_wrapper : public nano::websocket::websocket_stream_concept return strand; } + socket_type & get_socket () override + { + return ws.next_layer (); + } + void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) override { ws.close (reason_a, ec_a); @@ -105,6 +110,11 @@ nano::websocket::stream::stream (socket_type socket_a) return impl->get_strand (); } +[[nodiscard]] socket_type & nano::websocket::stream::get_socket () +{ + return impl->get_socket (); +} + void nano::websocket::stream::handshake (std::function callback_a) { impl->handshake (callback_a); diff --git a/nano/node/websocket_stream.hpp b/nano/node/websocket_stream.hpp index 03e21490ce..5a5cb86c45 100644 --- a/nano/node/websocket_stream.hpp +++ b/nano/node/websocket_stream.hpp @@ -32,6 +32,7 @@ class websocket_stream_concept public: virtual ~websocket_stream_concept () = default; virtual boost::asio::strand & get_strand () = 0; + virtual socket_type & get_socket () = 0; virtual void handshake (std::function callback_a) = 0; virtual void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) = 0; virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) = 0; @@ -51,6 +52,7 @@ class stream final : public websocket_stream_concept stream (socket_type socket_a); [[nodiscard]] boost::asio::strand & get_strand () override; + [[nodiscard]] socket_type & get_socket () override; void handshake (std::function callback_a) override; void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) override; void async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) override; diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 2c8b6cfb1b..7daf3a36fe 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -1546,7 +1546,7 @@ nano_qt::settings::settings (nano_qt::wallet & wallet_a) : retype_password->setPlaceholderText ("Retype password"); show_button_success (*change); change->setText ("Password was changed"); - this->wallet.node.logger.try_log ("Wallet password changed"); + this->wallet.node.nlogger.warn (nano::log::type::qt, "Wallet password changed"); update_locked (false, false); this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () { this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () { @@ -1639,7 +1639,7 @@ nano_qt::settings::settings (nano_qt::wallet & wallet_a) : this->wallet.wallet_m->store.password.value_set (empty); update_locked (true, true); lock_toggle->setText ("Unlock"); - this->wallet.node.logger.try_log ("Wallet locked"); + this->wallet.node.nlogger.warn (nano::log::type::qt, "Wallet locked"); password->setEnabled (1); } else diff --git a/nano/qt_test/entry.cpp b/nano/qt_test/entry.cpp index 0352439ec6..6208cbb229 100644 --- a/nano/qt_test/entry.cpp +++ b/nano/qt_test/entry.cpp @@ -1,8 +1,10 @@ +#include #include #include #include + QApplication * test_application = nullptr; namespace nano { @@ -15,6 +17,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; QApplication application (argc, argv); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index f7b1b41ae3..b69559b353 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -522,7 +522,8 @@ TEST (history, short_text) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path (), nano::dev::constants); + nano::nlogger nlogger; + auto store = nano::make_store (nlogger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); { @@ -559,7 +560,8 @@ TEST (history, pruned_source) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path (), nano::dev::constants); + nano::nlogger nlogger; + auto store = nano::make_store (nlogger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); ledger.pruning = true; diff --git a/nano/rpc/rpc.cpp b/nano/rpc/rpc.cpp index 18c0e5a227..6209810352 100644 --- a/nano/rpc/rpc.cpp +++ b/nano/rpc/rpc.cpp @@ -15,7 +15,6 @@ nano::rpc::rpc (boost::asio::io_context & io_ctx_a, nano::rpc_config config_a, nano::rpc_handler_interface & rpc_handler_interface_a) : config (std::move (config_a)), acceptor (io_ctx_a), - logger (std::chrono::milliseconds (0)), io_ctx (io_ctx_a), rpc_handler_interface (rpc_handler_interface_a) { @@ -33,13 +32,13 @@ nano::rpc::~rpc () void nano::rpc::start () { auto endpoint (boost::asio::ip::tcp::endpoint (boost::asio::ip::make_address_v6 (config.address), config.port)); + bool const is_loopback = (endpoint.address ().is_loopback () || (endpoint.address ().to_v6 ().is_v4_mapped () && boost::asio::ip::make_address_v4 (boost::asio::ip::v4_mapped, endpoint.address ().to_v6 ()).is_loopback ())); if (!is_loopback && config.enable_control) { - auto warning = boost::str (boost::format ("WARNING: control-level RPCs are enabled on non-local address %1%, potentially allowing wallet access outside local computer") % endpoint.address ().to_string ()); - std::cout << warning << std::endl; - logger.always_log (warning); + nlogger.warn (nano::log::type::rpc, "WARNING: Control-level RPCs are enabled on non-local address {}, potentially allowing wallet access outside local computer", endpoint.address ().to_string ()); } + acceptor.open (endpoint.protocol ()); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); @@ -47,7 +46,7 @@ void nano::rpc::start () acceptor.bind (endpoint, ec); if (ec) { - logger.always_log (boost::str (boost::format ("Error while binding for RPC on port %1%: %2%") % endpoint.port () % ec.message ())); + nlogger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ()); throw std::runtime_error (ec.message ()); } acceptor.listen (); @@ -56,7 +55,7 @@ void nano::rpc::start () void nano::rpc::accept () { - auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface)); + auto connection (std::make_shared (config, io_ctx, nlogger, rpc_handler_interface)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) { if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { @@ -68,7 +67,7 @@ void nano::rpc::accept () } else { - logger.always_log (boost::str (boost::format ("Error accepting RPC connections: %1% (%2%)") % ec.message () % ec.value ())); + nlogger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); } })); } diff --git a/nano/rpc/rpc.hpp b/nano/rpc/rpc.hpp index 40c096f37c..695de1467a 100644 --- a/nano/rpc/rpc.hpp +++ b/nano/rpc/rpc.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include +#include #include #include @@ -31,9 +31,9 @@ class rpc return acceptor.local_endpoint ().port (); } + nano::nlogger nlogger{ "rpc" }; nano::rpc_config config; boost::asio::ip::tcp::acceptor acceptor; - nano::logger_mt logger; boost::asio::io_context & io_ctx; nano::rpc_handler_interface & rpc_handler_interface; bool stopped{ false }; diff --git a/nano/rpc/rpc_connection.cpp b/nano/rpc/rpc_connection.cpp index f4d96be45b..4d0232bf63 100644 --- a/nano/rpc/rpc_connection.cpp +++ b/nano/rpc/rpc_connection.cpp @@ -14,11 +14,11 @@ #endif #include -nano::rpc_connection::rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger_mt & logger, nano::rpc_handler_interface & rpc_handler_interface) : +nano::rpc_connection::rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::nlogger & nlogger, nano::rpc_handler_interface & rpc_handler_interface) : socket (io_ctx), strand (io_ctx.get_executor ()), io_ctx (io_ctx), - logger (logger), + nlogger (nlogger), rpc_config (rpc_config), rpc_handler_interface (rpc_handler_interface) { @@ -84,7 +84,7 @@ void nano::rpc_connection::read (STREAM_TYPE & stream) } else { - this_l->logger.always_log ("RPC header error: ", ec.message ()); + this_l->nlogger.error (nano::log::type::rpc_connection, "RPC header error: ", ec.message ()); // Respond with the reason for the invalid header auto response_handler ([this_l, &stream] (std::string const & tree_a) { @@ -123,12 +123,9 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< this_l->write_completion_handler (this_l); })); - std::stringstream ss; - if (this_l->rpc_config.rpc_logging.log_rpc) - { - ss << "RPC request " << request_id << " completed in: " << std::chrono::duration_cast (std::chrono::steady_clock::now () - start).count () << " microseconds"; - this_l->logger.always_log (ss.str ().c_str ()); - } + // Bump logging level if RPC request logging is enabled + this_l->nlogger.log (this_l->rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, + nano::log::type::rpc_request, "RPC request {} completed in {} microseconds", request_id, std::chrono::duration_cast (std::chrono::steady_clock::now () - start).count ()); }); std::string api_path_l = "/api/v2"; @@ -139,7 +136,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< { case boost::beast::http::verb::post: { - auto handler (std::make_shared (this_l->rpc_config, req.body (), request_id, response_handler, this_l->rpc_handler_interface, this_l->logger)); + auto handler (std::make_shared (this_l->rpc_config, req.body (), request_id, response_handler, this_l->rpc_handler_interface, this_l->nlogger)); nano::rpc_handler_request_params request_params; request_params.rpc_version = rpc_version_l; request_params.credentials = header_field_credentials_l; @@ -168,7 +165,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< } else { - this_l->logger.always_log ("RPC read error: ", ec.message ()); + this_l->nlogger.error (nano::log::type::rpc_connection, "RPC read error: ", ec.message ()); } })); } diff --git a/nano/rpc/rpc_connection.hpp b/nano/rpc/rpc_connection.hpp index 3226e28064..e0f18367ff 100644 --- a/nano/rpc/rpc_connection.hpp +++ b/nano/rpc/rpc_connection.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include @@ -25,7 +26,7 @@ class rpc_handler_interface; class rpc_connection : public std::enable_shared_from_this { public: - rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger_mt & logger, nano::rpc_handler_interface & rpc_handler_interface_a); + rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::nlogger &, nano::rpc_handler_interface & rpc_handler_interface_a); virtual ~rpc_connection () = default; virtual void parse_connection (); virtual void write_completion_handler (std::shared_ptr const & rpc_connection); @@ -38,7 +39,7 @@ class rpc_connection : public std::enable_shared_from_this boost::asio::strand strand; std::atomic_flag responded; boost::asio::io_context & io_ctx; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::rpc_config const & rpc_config; nano::rpc_handler_interface & rpc_handler_interface; diff --git a/nano/rpc/rpc_handler.cpp b/nano/rpc/rpc_handler.cpp index 7148d45d63..9e4f7fa13f 100644 --- a/nano/rpc/rpc_handler.cpp +++ b/nano/rpc/rpc_handler.cpp @@ -18,13 +18,13 @@ std::unordered_set rpc_control_impl_set = create_rpc_control_impls std::string filter_request (boost::property_tree::ptree tree_a); } -nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger) : +nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::nlogger & nlogger) : body (body_a), request_id (request_id_a), response (response_a), rpc_config (rpc_config), rpc_handler_interface (rpc_handler_interface_a), - logger (logger) + nlogger (nlogger) { } @@ -62,13 +62,10 @@ void nano::rpc_handler::process_request (nano::rpc_handler_request_params const } auto action = request.get ("action"); - if (rpc_config.rpc_logging.log_rpc) - { - // Creating same string via stringstream as using it directly is generating a TSAN warning - std::stringstream ss; - ss << request_id; - logger.always_log (ss.str (), " ", filter_request (request)); - } + + // Bump logging level if RPC request logging is enabled + nlogger.log (rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, + nano::log::type::rpc_request, "Request {} : {}", request_id, filter_request (request)); // Check if this is a RPC command which requires RPC enabled control std::error_code rpc_control_disabled_ec = nano::error_rpc::rpc_control_disabled; diff --git a/nano/rpc/rpc_handler.hpp b/nano/rpc/rpc_handler.hpp index 2e919f303a..92850497cc 100644 --- a/nano/rpc/rpc_handler.hpp +++ b/nano/rpc/rpc_handler.hpp @@ -1,5 +1,7 @@ #pragma once +#include + #include #include @@ -15,7 +17,7 @@ class rpc_handler_request_params; class rpc_handler : public std::enable_shared_from_this { public: - rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger); + rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::nlogger &); void process_request (nano::rpc_handler_request_params const & request_params); private: @@ -25,6 +27,6 @@ class rpc_handler : public std::enable_shared_from_this std::function response; nano::rpc_config const & rpc_config; nano::rpc_handler_interface & rpc_handler_interface; - nano::logger_mt & logger; + nano::nlogger & nlogger; }; } diff --git a/nano/rpc/rpc_secure.cpp b/nano/rpc/rpc_secure.cpp index 3f596a7cba..8548a8f843 100644 --- a/nano/rpc/rpc_secure.cpp +++ b/nano/rpc/rpc_secure.cpp @@ -15,7 +15,7 @@ nano::rpc_secure::rpc_secure (boost::asio::io_context & context_a, nano::rpc_con void nano::rpc_secure::accept () { - auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface, config.tls_config->ssl_context)); + auto connection (std::make_shared (config, io_ctx, nlogger, rpc_handler_interface, config.tls_config->ssl_context)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) { if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { @@ -27,7 +27,7 @@ void nano::rpc_secure::accept () } else { - logger.always_log (boost::str (boost::format ("Error accepting RPC connections: %1%") % ec)); + nlogger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); } })); } diff --git a/nano/rpc_test/entry.cpp b/nano/rpc_test/entry.cpp index 530f146c98..3f81484360 100644 --- a/nano/rpc_test/entry.cpp +++ b/nano/rpc_test/entry.cpp @@ -1,7 +1,9 @@ +#include #include #include #include + namespace nano { namespace test @@ -13,6 +15,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::set_use_memory_pools (false); nano::node_singleton_memory_pool_purge_guard cleanup_guard; diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 35b5ad68f9..525083669d 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index e7c7f1abf9..e7c511b8bd 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -1558,13 +1559,13 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (std::filesystem::path const & data_p auto rockdb_data_path = data_path_a / "rocksdb"; std::filesystem::remove_all (rockdb_data_path); - nano::logger_mt logger; + nano::nlogger nlogger; auto error (false); // Open rocksdb database nano::rocksdb_config rocksdb_config; rocksdb_config.enable = true; - auto rocksdb_store = nano::make_store (logger, data_path_a, nano::dev::constants, false, true, rocksdb_config); + auto rocksdb_store = nano::make_store (nlogger, data_path_a, nano::dev::constants, false, true, rocksdb_config); if (!rocksdb_store->init_error ()) { diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index c1e2b11817..6cabac2eee 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -17,9 +17,6 @@ namespace nano { class stats; -// map of vote weight per block, ordered greater first -using tally_t = std::map, std::greater>; - class uncemented_info { public: diff --git a/nano/secure/vote.cpp b/nano/secure/vote.cpp index 2f19c9748e..208aca4de1 100644 --- a/nano/secure/vote.cpp +++ b/nano/secure/vote.cpp @@ -165,13 +165,9 @@ std::string nano::vote::to_json () const std::string nano::vote::hashes_string () const { - std::string result; - for (auto const & hash : hashes) - { - result += hash.to_string (); - result += ", "; - } - return result; + return nano::util::join (hashes, ",", [] (auto const & hash) { + return hash.to_string (); + }); } uint64_t nano::vote::packed_timestamp (uint64_t timestamp, uint8_t duration) @@ -184,13 +180,4 @@ uint64_t nano::vote::packed_timestamp (uint64_t timestamp, uint8_t duration) bool nano::vote::is_final_timestamp (uint64_t timestamp) { return timestamp == std::numeric_limits::max (); -} - -/* - * iterate_vote_blocks_as_hash - */ - -nano::block_hash nano::iterate_vote_blocks_as_hash::operator() (nano::block_hash const & item) const -{ - return item; -} +} \ No newline at end of file diff --git a/nano/secure/vote.hpp b/nano/secure/vote.hpp index 35d7308a13..d7c9b62b32 100644 --- a/nano/secure/vote.hpp +++ b/nano/secure/vote.hpp @@ -12,14 +12,6 @@ namespace nano { -using vote_blocks_vec_iter = std::vector::const_iterator; -class iterate_vote_blocks_as_hash final -{ -public: - iterate_vote_blocks_as_hash () = default; - nano::block_hash operator() (nano::block_hash const & item) const; -}; - class vote final { public: @@ -43,9 +35,6 @@ class vote final bool operator== (nano::vote const &) const; bool operator!= (nano::vote const &) const; - boost::transform_iterator begin () const; - boost::transform_iterator end () const; - void serialize_json (boost::property_tree::ptree & tree) const; std::string to_json () const; std::string hashes_string () const; diff --git a/nano/slow_test/entry.cpp b/nano/slow_test/entry.cpp index cc8fd2e18e..d7cf3c6846 100644 --- a/nano/slow_test/entry.cpp +++ b/nano/slow_test/entry.cpp @@ -1,6 +1,8 @@ +#include #include #include + namespace nano { namespace test @@ -12,6 +14,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { + nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; testing::InitGoogleTest (&argc, argv); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 2bb0075c01..db710f87ba 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -116,7 +117,7 @@ TEST (system, receive_while_synchronizing) TEST (ledger, deep_account_compute) { - nano::logger_mt logger; + nano::nlogger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -536,7 +537,7 @@ TEST (store, vote_load) */ TEST (store, pruned_load) { - nano::logger_mt logger; + nano::nlogger logger; auto path (nano::unique_path ()); constexpr auto num_pruned = 2000000; auto const expected_result = num_pruned / 2; @@ -1222,8 +1223,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) // Don't test this in rocksdb mode return; } - nano::logger_mt logger; - nano::logging logging; + nano::nlogger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1235,7 +1235,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) boost::latch initialized_latch{ 0 }; nano::block_hash block_hash_being_processed{ 0 }; - nano::confirmation_height_processor confirmation_height_processor{ ledger, write_database_queue, 10ms, logging, logger, initialized_latch, confirmation_height_mode::automatic }; + nano::confirmation_height_processor confirmation_height_processor{ ledger, write_database_queue, 10ms, logger, initialized_latch, confirmation_height_mode::automatic }; auto const num_accounts = 100000; diff --git a/nano/store/lmdb/lmdb.cpp b/nano/store/lmdb/lmdb.cpp index 8834c38d01..ccc5a4934c 100644 --- a/nano/store/lmdb/lmdb.cpp +++ b/nano/store/lmdb/lmdb.cpp @@ -12,7 +12,7 @@ #include -nano::store::lmdb::component::component (nano::logger_mt & logger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : +nano::store::lmdb::component::component (nano::nlogger & nlogger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : // clang-format off nano::store::component{ block_store, @@ -37,9 +37,9 @@ nano::store::lmdb::component::component (nano::logger_mt & logger_a, std::filesy confirmation_height_store{ *this }, final_vote_store{ *this }, version_store{ *this }, - logger (logger_a), + nlogger{ nlogger_a }, env (error, path_a, nano::store::lmdb::env::options::make ().set_config (lmdb_config_a).set_use_no_mem_init (true)), - mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a), + mdb_txn_tracker (nlogger_a, txn_tracking_config_a, block_processor_batch_max_time_a), txn_tracking_enabled (txn_tracking_config_a.enable) { if (!error) @@ -66,10 +66,11 @@ nano::store::lmdb::component::component (nano::logger_mt & logger_a, std::filesy { if (!is_fresh_db) { - logger.always_log ("Upgrade in progress..."); + nlogger.info (nano::log::type::lmdb, "Upgrade in progress..."); + if (backup_before_upgrade_a) { - create_backup_file (env, path_a, logger_a); + create_backup_file (env, path_a, nlogger); } } auto needs_vacuuming = false; @@ -84,9 +85,18 @@ nano::store::lmdb::component::component (nano::logger_mt & logger_a, std::filesy if (needs_vacuuming) { - logger.always_log ("Preparing vacuum..."); + nlogger.info (nano::log::type::lmdb, "Ledger vaccum in progress..."); + auto vacuum_success = vacuum_after_upgrade (path_a, lmdb_config_a); - logger.always_log (vacuum_success ? "Vacuum succeeded." : "Failed to vacuum. (Optional) Ensure enough disk space is available for a copy of the database and try to vacuum after shutting down the node"); + if (vacuum_success) + { + nlogger.info (nano::log::type::lmdb, "Ledger vacuum completed"); + } + else + { + nlogger.error (nano::log::type::lmdb, "Ledger vaccum failed"); + nlogger.error (nano::log::type::lmdb, "(Optional) Please ensure enough disk space is available for a copy of the database and try to vacuum after shutting down the node"); + } } } else @@ -202,7 +212,7 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans auto version_l = version.get (transaction_a); if (version_l < version_minimum) { - logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is lower than the minimum (%2%) which is supported for upgrades. Either upgrade to a v19, v20 or v21 node first or delete the ledger.") % version_l % version_minimum)); + nlogger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); return true; } switch (version_l) @@ -213,7 +223,7 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans case 22: break; default: - logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is too high for this node") % version_l)); + nlogger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is too high for this node", version_l); error = true; break; } @@ -222,16 +232,18 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans void nano::store::lmdb::component::upgrade_v21_to_v22 (store::write_transaction const & transaction_a) { - logger.always_log ("Preparing v21 to v22 database upgrade..."); + nlogger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22..."); + MDB_dbi unchecked_handle{ 0 }; release_assert (!mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE, &unchecked_handle)); release_assert (!mdb_drop (env.tx (transaction_a), unchecked_handle, 1)); // del = 1, to delete it from the environment and close the DB handle. version.put (transaction_a, 22); - logger.always_log ("Finished removing unchecked table"); + + nlogger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22 completed"); } /** Takes a filepath, appends '_backup_' to the end (but before any extension) and saves that file in the same directory */ -void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & env_a, std::filesystem::path const & filepath_a, nano::logger_mt & logger_a) +void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & env_a, std::filesystem::path const & filepath_a, nano::nlogger & nlogger) { auto extension = filepath_a.extension (); auto filename_without_extension = filepath_a.filename ().replace_extension (""); @@ -242,22 +254,18 @@ void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & backup_filename += std::to_string (std::chrono::system_clock::now ().time_since_epoch ().count ()); backup_filename += extension; auto backup_filepath = backup_path / backup_filename; - auto start_message (boost::str (boost::format ("Performing %1% backup before database upgrade...") % filepath_a.filename ())); - logger_a.always_log (start_message); - std::cout << start_message << std::endl; + + nlogger.info (nano::log::type::lmdb, "Performing {} backup before database upgrade...", filepath_a.filename ().string ()); + auto error (mdb_env_copy (env_a, backup_filepath.string ().c_str ())); if (error) { - auto error_message (boost::str (boost::format ("%1% backup failed") % filepath_a.filename ())); - logger_a.always_log (error_message); - std::cerr << error_message << std::endl; + nlogger.critical (nano::log::type::lmdb, "Database backup failed"); std::exit (1); } else { - auto success_message (boost::str (boost::format ("Backup created: %1%") % backup_filename)); - logger_a.always_log (success_message); - std::cout << success_message << std::endl; + nlogger.info (nano::log::type::lmdb, "Database backup completed. Backup can be found at: {}", backup_filepath.string ()); } } diff --git a/nano/store/lmdb/lmdb.hpp b/nano/store/lmdb/lmdb.hpp index 91822f7f95..5b28dbdf11 100644 --- a/nano/store/lmdb/lmdb.hpp +++ b/nano/store/lmdb/lmdb.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include #include @@ -63,7 +63,7 @@ class component : public nano::store::component friend class nano::store::lmdb::version; public: - component (nano::logger_mt &, std::filesystem::path const &, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); + component (nano::nlogger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); store::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; store::read_transaction tx_begin_read () const override; @@ -71,14 +71,14 @@ class component : public nano::store::component void serialize_mdb_tracker (boost::property_tree::ptree &, std::chrono::milliseconds, std::chrono::milliseconds) override; - static void create_backup_file (nano::store::lmdb::env &, std::filesystem::path const &, nano::logger_mt &); + static void create_backup_file (nano::store::lmdb::env &, std::filesystem::path const &, nano::nlogger &); void serialize_memory_stats (boost::property_tree::ptree &) override; unsigned max_block_write_batch_num () const override; private: - nano::logger_mt & logger; + nano::nlogger & nlogger; bool error{ false }; public: diff --git a/nano/store/lmdb/transaction.cpp b/nano/store/lmdb/transaction.cpp index a01698c09d..c75fdc736c 100644 --- a/nano/store/lmdb/transaction.cpp +++ b/nano/store/lmdb/transaction.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -116,8 +116,8 @@ bool nano::store::lmdb::write_transaction_impl::contains (nano::tables table_a) return true; } -nano::mdb_txn_tracker::mdb_txn_tracker (nano::logger_mt & logger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a) : - logger (logger_a), +nano::mdb_txn_tracker::mdb_txn_tracker (nano::nlogger & nlogger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a) : + nlogger (nlogger_a), txn_tracking_config (txn_tracking_config_a), block_processor_batch_max_time (block_processor_batch_max_time_a) { @@ -194,7 +194,12 @@ void nano::mdb_txn_tracker::log_if_held_long_enough (nano::mdb_txn_stats const & 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))) { 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)); + + nlogger.warn (nano::log::type::txn_tracker, "{}ms {} held on thread {}\n{}", + time_open.count (), + is_write ? "write lock" : "read", + mdb_txn_stats.thread_name, + nano::util::to_str (*mdb_txn_stats.stacktrace)); } } diff --git a/nano/store/lmdb/transaction_impl.hpp b/nano/store/lmdb/transaction_impl.hpp index 001fd896a3..971908b5da 100644 --- a/nano/store/lmdb/transaction_impl.hpp +++ b/nano/store/lmdb/transaction_impl.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -11,10 +12,6 @@ #include -namespace nano -{ -class logger_mt; -} namespace nano::store::lmdb { class env; @@ -75,7 +72,7 @@ class mdb_txn_stats class mdb_txn_tracker { public: - mdb_txn_tracker (nano::logger_mt & logger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a); + mdb_txn_tracker (nano::nlogger &, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a); void serialize_json (boost::property_tree::ptree & json, std::chrono::milliseconds min_read_time, std::chrono::milliseconds min_write_time); void add (store::transaction_impl const * transaction_impl); void erase (store::transaction_impl const * transaction_impl); @@ -83,7 +80,7 @@ class mdb_txn_tracker private: nano::mutex mutex; std::vector stats; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::txn_tracking_config txn_tracking_config; std::chrono::milliseconds block_processor_batch_max_time; diff --git a/nano/store/rocksdb/rocksdb.cpp b/nano/store/rocksdb/rocksdb.cpp index 054fec0a82..a29e301311 100644 --- a/nano/store/rocksdb/rocksdb.cpp +++ b/nano/store/rocksdb/rocksdb.cpp @@ -34,7 +34,7 @@ class event_listener : public rocksdb::EventListener }; } -nano::store::rocksdb::component::component (nano::logger_mt & logger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : +nano::store::rocksdb::component::component (nano::nlogger & nlogger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : // clang-format off nano::store::component{ block_store, @@ -59,7 +59,7 @@ nano::store::rocksdb::component::component (nano::logger_mt & logger_a, std::fil confirmation_height_store{ *this }, final_vote_store{ *this }, version_store{ *this }, - logger{ logger_a }, + nlogger{ nlogger_a }, constants{ constants }, rocksdb_config{ rocksdb_config_a }, max_block_write_batch_num_m{ nano::narrow_cast (blocks_memtable_size_bytes () / (2 * (sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)))) }, @@ -95,14 +95,16 @@ nano::store::rocksdb::component::component (nano::logger_mt & logger_a, std::fil auto version_l = version.get (transaction); if (version_l > version_current) { + nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); + error = true; - logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is too high for this node") % version_l)); return; } else if (version_l < version_minimum) { + nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); + error = true; - logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is lower than the minimum (%2%) which is supported for upgrades. Either upgrade to a v19, v20 or v21 node first or delete the ledger.") % version_l % version_minimum)); return; } is_fully_upgraded = (version_l == version_current); @@ -149,7 +151,8 @@ nano::store::rocksdb::component::component (nano::logger_mt & logger_a, std::fil open (error, path_a, open_read_only_a, options, get_current_column_families (path_a.string (), options)); if (!error) { - logger.always_log ("Upgrade in progress..."); + nlogger.info (nano::log::type::rocksdb, "Upgrade in progress..."); + auto transaction = tx_begin_write (); error |= do_upgrades (transaction); } @@ -240,7 +243,7 @@ bool nano::store::rocksdb::component::do_upgrades (store::write_transaction cons case 22: break; default: - logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is too high for this node") % version_l)); + nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); error_l = true; break; } @@ -249,7 +252,8 @@ bool nano::store::rocksdb::component::do_upgrades (store::write_transaction cons void nano::store::rocksdb::component::upgrade_v21_to_v22 (store::write_transaction const & transaction_a) { - logger.always_log ("Preparing v21 to v22 database upgrade..."); + nlogger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22..."); + if (column_family_exists ("unchecked")) { auto const unchecked_handle = get_column_family ("unchecked"); @@ -264,9 +268,12 @@ void nano::store::rocksdb::component::upgrade_v21_to_v22 (store::write_transacti } return false; }); + nlogger.debug (nano::log::type::rocksdb, "Finished removing unchecked table"); } + version.put (transaction_a, 22); - logger.always_log ("Finished removing unchecked table"); + + nlogger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22 completed"); } void nano::store::rocksdb::component::generate_tombstone_map () @@ -909,7 +916,7 @@ bool nano::store::rocksdb::component::copy_db (std::filesystem::path const & des // Open it so that it flushes all WAL files if (status.ok ()) { - nano::store::rocksdb::component rocksdb_store{ logger, destination_path.string (), constants, rocksdb_config, false }; + nano::store::rocksdb::component rocksdb_store{ nlogger, destination_path.string (), constants, rocksdb_config, false }; return !rocksdb_store.init_error (); } return false; diff --git a/nano/store/rocksdb/rocksdb.hpp b/nano/store/rocksdb/rocksdb.hpp index 9490ed9522..92a093504f 100644 --- a/nano/store/rocksdb/rocksdb.hpp +++ b/nano/store/rocksdb/rocksdb.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include +#include #include #include #include @@ -36,8 +36,8 @@ namespace nano::store::rocksdb class rocksdb_block_store_upgrade_v21_v22_Test; /** - * rocksdb implementation of the block store - */ + * rocksdb implementation of the block store + */ class component : public nano::store::component { private: @@ -64,7 +64,7 @@ class component : public nano::store::component friend class nano::store::rocksdb::pruned; friend class nano::store::rocksdb::version; - explicit component (nano::logger_mt &, std::filesystem::path const &, nano::ledger_constants & constants, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); + explicit component (nano::nlogger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); store::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; store::read_transaction tx_begin_read () const override; @@ -103,7 +103,7 @@ class component : public nano::store::component private: bool error{ false }; - nano::logger_mt & logger; + nano::nlogger & nlogger; nano::ledger_constants & constants; // Optimistic transactions are used in write mode ::rocksdb::OptimisticTransactionDB * optimistic_db = nullptr; diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index a3337bc925..7755ebaa7a 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -3,7 +3,7 @@ #include nano::test::context::ledger_context::ledger_context (std::deque> && blocks) : - store_m{ nano::make_store (logger, nano::unique_path (), nano::dev::constants) }, + store_m{ nano::make_store (nlogger, nano::unique_path (), nano::dev::constants) }, ledger_m{ *store_m, stats_m, nano::dev::constants }, blocks_m{ blocks } { diff --git a/nano/test_common/ledger.hpp b/nano/test_common/ledger.hpp index 6d64e170e4..704ff0b1c7 100644 --- a/nano/test_common/ledger.hpp +++ b/nano/test_common/ledger.hpp @@ -26,7 +26,7 @@ namespace test std::deque> const & blocks () const; private: - nano::logger_mt logger; + nano::nlogger nlogger; std::unique_ptr store_m; nano::stats stats_m; nano::ledger ledger_m; diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index b0f2ff1dfc..650ba3eed0 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -619,10 +619,9 @@ uint16_t nano::test::system::get_available_port (bool can_be_zero) } } +// Makes sure everything is cleaned up void nano::test::cleanup_dev_directories_on_exit () { - // Makes sure everything is cleaned up - nano::logging::release_file_sink (); // Clean up tmp directories created by the tests. Since it's sometimes useful to // see log files after test failures, an environment variable is supported to // retain the files. diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index e03532ccef..f0f31afd92 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -68,6 +68,7 @@ namespace test std::vector> nodes; nano::logging logging; nano::stats stats; + nano::nlogger nlogger; nano::work_pool work{ nano::dev::network_params.network, std::max (nano::hardware_concurrency (), 1u) }; std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; double deadline_scaling_factor{ 1.0 }; From 4a26ca7f474bb8b9c203e875de95f007e3544478 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 16 Jan 2024 19:34:20 +0100 Subject: [PATCH 008/190] Remove legacy logger --- CMakeLists.txt | 4 - nano/core_test/block_store.cpp | 2 +- nano/core_test/bootstrap.cpp | 36 +- nano/core_test/confirmation_height.cpp | 1 - nano/core_test/core_test_main.cc | 4 - nano/core_test/logger.cpp | 98 +---- nano/core_test/network.cpp | 16 +- nano/core_test/node.cpp | 89 +++-- nano/core_test/toml.cpp | 58 --- nano/core_test/unchecked_map.cpp | 1 - nano/core_test/work_pool.cpp | 3 - nano/lib/CMakeLists.txt | 3 - nano/lib/logger_mt.hpp | 139 ------- nano/nano_node/daemon.cpp | 2 - nano/nano_node/entry.cpp | 9 - nano/nano_rpc/entry.cpp | 20 +- nano/nano_wallet/entry.cpp | 2 - nano/node/CMakeLists.txt | 4 - nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap/bootstrap_connections.cpp | 23 +- nano/node/confirmation_height_bounded.cpp | 2 - nano/node/confirmation_height_bounded.hpp | 2 - nano/node/confirmation_height_processor.cpp | 1 - nano/node/confirmation_height_unbounded.cpp | 2 - nano/node/confirmation_height_unbounded.hpp | 2 - nano/node/ipc/ipc_server.cpp | 2 - nano/node/logging.cpp | 344 ------------------ nano/node/logging.hpp | 105 ------ nano/node/node.cpp | 7 +- nano/node/node.hpp | 4 +- nano/node/nodeconfig.cpp | 15 +- nano/node/nodeconfig.hpp | 4 +- nano/node/vote_processor.cpp | 5 +- nano/rpc/rpc_connection.cpp | 1 - nano/rpc/rpc_connection.hpp | 1 - nano/rpc/rpc_handler.cpp | 1 - nano/rpc/rpc_handler.hpp | 1 - nano/rpc_test/rpc.cpp | 3 +- nano/slow_test/node.cpp | 4 +- nano/test_common/CMakeLists.txt | 2 +- nano/test_common/ledger.hpp | 1 - nano/test_common/network.cpp | 2 +- nano/test_common/system.cpp | 3 +- nano/test_common/system.hpp | 1 - nano/test_common/testutil.hpp | 50 --- 45 files changed, 99 insertions(+), 982 deletions(-) delete mode 100644 nano/lib/logger_mt.hpp delete mode 100644 nano/node/logging.cpp delete mode 100644 nano/node/logging.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 925be3b5a2..cbdb7bf6cc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -483,10 +483,6 @@ include_directories(${BOOST_LIBRARY_INCLUDES}) add_library(Boost::stacktrace ALIAS boost_stacktrace_basic) add_definitions(-DBOOST_STACKTRACE_GNU_SOURCE_NOT_REQUIRED) -# Workaround for GitHub builders which do not appear to have the Windows Message -# Compiler mc.exe -add_definitions(-DBOOST_LOG_WITHOUT_EVENT_LOG) - # Workaround for missing reference errata in the boost property_tree module target_link_libraries(boost_property_tree INTERFACE Boost::any) target_link_libraries(boost_property_tree INTERFACE Boost::format) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index db456d6bbc..48808e2f31 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index f2297aff71..10198e45de 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -283,7 +283,7 @@ TEST (bulk_pull, count_limit) TEST (bootstrap_processor, DISABLED_process_none) { nano::test::system system (1); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); auto done (false); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint (), false); @@ -338,7 +338,7 @@ TEST (bootstrap_processor, process_two) ASSERT_NE (hash1, hash3); ASSERT_NE (hash2, hash3); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); @@ -384,7 +384,7 @@ TEST (bootstrap_processor, process_state) ASSERT_EQ (nano::process_result::progress, node0->process (*block2).code); config.peering_port = system.get_available_port (); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); ASSERT_EQ (node0->latest (nano::dev::genesis_key.pub), block2->hash ()); ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), block2->hash ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -415,7 +415,7 @@ TEST (bootstrap_processor, process_new) nano::uint128_t balance2 (node1->balance (key2.pub)); ASSERT_TIMELY (10s, node1->block_confirmed (send->hash ()) && node1->block_confirmed (receive->hash ()) && node1->active.empty () && node2->active.empty ()); // All blocks should be propagated & confirmed - auto node3 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node3 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node3->init_error ()); node3->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); ASSERT_TIMELY_EQ (10s, node3->balance (key2.pub), balance2); @@ -468,7 +468,7 @@ TEST (bootstrap_processor, pull_diamond) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_TIMELY_EQ (10s, node1->balance (nano::dev::genesis_key.pub), 100); @@ -529,7 +529,7 @@ TEST (bootstrap_processor, DISABLED_push_diamond) config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 (system.add_node (config)); nano::keypair key; - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); auto wallet1 (node1->wallets.create (100)); wallet1->insert_adhoc (nano::dev::genesis_key.prv); @@ -662,7 +662,7 @@ TEST (bootstrap_processor, push_one) config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 (system.add_node (config)); nano::keypair key1; - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); wallet->insert_adhoc (nano::dev::genesis_key.prv); @@ -736,7 +736,7 @@ TEST (bootstrap_processor, lazy_hash) node0->block_processor.add (receive2); node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true); { @@ -810,7 +810,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) node0->block_processor.add (receive2); node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true, "123456"); { @@ -1052,7 +1052,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) node0->block_processor.add (change3); node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); // Check processed blocks @@ -1390,7 +1390,7 @@ TEST (bootstrap_processor, lazy_cancel) .build_shared (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (send1->hash (), true); // Start "confirmed" block bootstrap { @@ -1465,7 +1465,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) node0->block_processor.add (receive2); node0->block_processor.flush (); // Start wallet lazy bootstrap - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); @@ -1911,14 +1911,14 @@ TEST (frontier_req, confirmed_frontier) TEST (bulk, genesis) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node2->init_error ()); nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); @@ -1938,14 +1938,14 @@ TEST (bulk, genesis) TEST (bulk, offline_send) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node2->init_error ()); node2->start (); system.nodes.push_back (node2); @@ -1980,7 +1980,7 @@ TEST (bulk, offline_send) TEST (bulk, DISABLED_genesis_pruning) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; @@ -1991,7 +1991,7 @@ TEST (bulk, DISABLED_genesis_pruning) auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node_flags.enable_pruning = false; - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); ASSERT_FALSE (node2->init_error ()); nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 65ec67fabf..aaba8735fa 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -2101,7 +2101,6 @@ TEST (confirmation_height, unbounded_block_cache_iteration) TEST (confirmation_height, pruned_source) { nano::nlogger logger; - nano::logging logging; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index 883ed8e209..c2f2d22136 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -2,7 +2,6 @@ #include #include -#include #include #include @@ -24,9 +23,6 @@ GTEST_API_ int main (int argc, char ** argv) nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; - // Setting up logging so that there aren't any piped to standard output. - nano::logging logging; - logging.init (nano::unique_path ()); testing::InitGoogleTest (&argc, argv); auto res = RUN_ALL_TESTS (); nano::test::cleanup_dev_directories_on_exit (); diff --git a/nano/core_test/logger.cpp b/nano/core_test/logger.cpp index 4a318b9cca..a282736058 100644 --- a/nano/core_test/logger.cpp +++ b/nano/core_test/logger.cpp @@ -1,5 +1,4 @@ -#include -#include + #include #include @@ -11,98 +10,7 @@ using namespace std::chrono_literals; -TEST (logger, changing_time_interval) -{ - auto path1 (nano::unique_path ()); - nano::logging logging; - logging.init (path1); - logging.min_time_between_log_output = 0ms; - nano::logger_mt my_logger (logging.min_time_between_log_output); - auto error (my_logger.try_log ("logger.changing_time_interval1")); - ASSERT_FALSE (error); - my_logger.min_log_delta = 20s; - error = my_logger.try_log ("logger, changing_time_interval2"); - ASSERT_TRUE (error); -} - -TEST (logger, try_log) +TEST (logger, basic) { - auto path1 (nano::unique_path ()); - std::stringstream ss; - nano::test::boost_log_cerr_redirect redirect_cerr (ss.rdbuf ()); - nano::logger_mt my_logger (100ms); - auto output1 = "logger.try_log1"; - auto error (my_logger.try_log (output1)); - ASSERT_FALSE (error); - auto output2 = "logger.try_log2"; - error = my_logger.try_log (output2); - ASSERT_TRUE (error); // Fails as it is occuring too soon - - // Sleep for a bit and then confirm - std::this_thread::sleep_for (100ms); - error = my_logger.try_log (output2); - ASSERT_FALSE (error); - - std::string str; - std::getline (ss, str, '\n'); - ASSERT_STREQ (str.c_str (), output1); - std::getline (ss, str, '\n'); - ASSERT_STREQ (str.c_str (), output2); -} - -TEST (logger, always_log) -{ - auto path1 (nano::unique_path ()); - std::stringstream ss; - nano::test::boost_log_cerr_redirect redirect_cerr (ss.rdbuf ()); - nano::logger_mt my_logger (20s); // Make time interval effectively unreachable - auto output1 = "logger.always_log1"; - auto error (my_logger.try_log (output1)); - ASSERT_FALSE (error); - - // Time is too soon after, so it won't be logged - auto output2 = "logger.always_log2"; - error = my_logger.try_log (output2); - ASSERT_TRUE (error); - - // Force it to be logged - my_logger.always_log (output2); - - std::string str; - std::getline (ss, str, '\n'); - ASSERT_STREQ (str.c_str (), output1); - std::getline (ss, str, '\n'); - ASSERT_STREQ (str.c_str (), output2); -} - -TEST (logger, stable_filename) -{ - auto path (nano::unique_path ()); - nano::logging logging; - - // Releasing allows setting up logging again - logging.release_file_sink (); - - logging.stable_log_filename = true; - logging.init (path); - - nano::logger_mt logger (logging.min_time_between_log_output); - logger.always_log ("stable1"); - - auto log_file = path / "log" / "node.log"; - -#if BOOST_VERSION >= 107000 - EXPECT_TRUE (std::filesystem::exists (log_file)); - // Try opening it again - logging.release_file_sink (); - logging.init (path); - logger.always_log ("stable2"); -#else - // When using Boost < 1.70 , behavior is reverted to not using the stable filename - EXPECT_FALSE (std::filesystem::exists (log_file)); -#endif - - // Reset the logger - logging.release_file_sink (); - nano::logging ().init (path); + // TODO } diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 6804e7bb50..971263373c 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -58,7 +58,7 @@ TEST (network, construction_with_specified_port) { nano::test::system system{}; auto const port = system.get_available_port (/* do not allow 0 port */ false); - auto const node = system.add_node (nano::node_config{ port, system.logging }); + auto const node = system.add_node (nano::node_config{ port }); EXPECT_EQ (port, node->network.port); EXPECT_EQ (port, node->network.endpoint ().port ()); EXPECT_EQ (port, node->tcp_listener->endpoint ().port ()); @@ -79,7 +79,7 @@ TEST (network, send_node_id_handshake_tcp) nano::test::system system (1); auto node0 (system.nodes[0]); ASSERT_EQ (0, node0->network.size ()); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); node1->start (); system.nodes.push_back (node1); auto initial (node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); @@ -157,7 +157,7 @@ TEST (network, multi_keepalive) nano::test::system system (1); auto node0 = system.nodes[0]; ASSERT_EQ (0, node0->network.size ()); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); node1->start (); system.nodes.push_back (node1); @@ -165,7 +165,7 @@ TEST (network, multi_keepalive) ASSERT_EQ (0, node0->network.size ()); node1->network.tcp_channels.start_tcp (node0->network.endpoint ()); ASSERT_TIMELY (10s, node0->network.size () == 1 && node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive) >= 1); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node2->init_error ()); node2->start (); system.nodes.push_back (node2); @@ -749,7 +749,7 @@ TEST (network, peer_max_tcp_attempts) auto node = system.add_node (node_flags); for (auto i (0); i < node->network_params.network.max_peers_per_ip; ++i) { - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); node2->start (); system.nodes.push_back (node2); // Start TCP attempt @@ -826,7 +826,7 @@ TEST (network, duplicate_revert_publish) nano::uint128_t digest; ASSERT_FALSE (node.network.publish_filter.apply (bytes.data (), bytes.size (), &digest)); ASSERT_TRUE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); - auto other_node (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto other_node (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); other_node->start (); system.nodes.push_back (other_node); auto channel = nano::test::establish_tcp (system, *other_node, node.network.endpoint ()); @@ -957,7 +957,7 @@ TEST (network, tcp_no_connect_excluded_peers) nano::test::system system (1); auto node0 (system.nodes[0]); ASSERT_EQ (0, node0->network.size ()); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); node1->start (); system.nodes.push_back (node1); auto endpoint1_tcp (nano::transport::map_endpoint_to_tcp (node1->network.endpoint ())); @@ -1058,7 +1058,7 @@ TEST (network, cleanup_purge) nano::test::system system (1); auto & node1 (*system.nodes[0]); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); node2->start (); system.nodes.push_back (node2); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index b64d3d4cfd..69eae14b0e 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -68,10 +68,8 @@ TEST (node, block_store_path_failure) nano::test::system system; auto service (std::make_shared ()); auto path (nano::unique_path ()); - nano::logging logging; - logging.init (path); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; - auto node (std::make_shared (*service, system.get_available_port (), path, logging, pool)); + auto node (std::make_shared (*service, system.get_available_port (), path, pool)); ASSERT_TRUE (node->wallets.items.empty ()); node->stop (); } @@ -101,7 +99,6 @@ TEST (node, password_fanout) auto path (nano::unique_path ()); nano::node_config config; config.peering_port = system.get_available_port (); - config.logging.init (path); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; config.password_fanout = 10; nano::node node (io_ctx, path, config, pool); @@ -267,7 +264,7 @@ TEST (node, node_receive_quorum) TEST (node, auto_bootstrap) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; @@ -279,7 +276,7 @@ TEST (node, auto_bootstrap) auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); ASSERT_TIMELY_EQ (10s, node0->balance (key2.pub), node0->config.receive_minimum.number ()); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); ASSERT_FALSE (node1->init_error ()); node1->start (); system.nodes.push_back (node1); @@ -299,7 +296,7 @@ TEST (node, auto_bootstrap) TEST (node, auto_bootstrap_reverse) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; @@ -308,7 +305,7 @@ TEST (node, auto_bootstrap_reverse) nano::keypair key2; system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); ASSERT_FALSE (node1->init_error ()); ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); node1->start (); @@ -320,14 +317,14 @@ TEST (node, auto_bootstrap_reverse) TEST (node, auto_bootstrap_age) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; node_flags.bootstrap_interval = 1; auto node0 = system.add_node (config, node_flags); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); ASSERT_FALSE (node1->init_error ()); node1->start (); system.nodes.push_back (node1); @@ -417,7 +414,7 @@ TEST (node, search_receivable_multiple) TEST (node, search_receivable_confirmed) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); nano::keypair key2; @@ -451,12 +448,12 @@ TEST (node, search_receivable_confirmed) TEST (node, search_receivable_pruned) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node1 = system.add_node (node_config); nano::node_flags node_flags; node_flags.enable_pruning = true; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.enable_voting = false; // Remove after allowing pruned voting auto node2 = system.add_node (config, node_flags); nano::keypair key2; @@ -550,9 +547,7 @@ TEST (node, confirm_locked) TEST (node_config, random_rep) { auto path (nano::unique_path ()); - nano::logging logging1; - logging1.init (path); - nano::node_config config1 (100, logging1); + nano::node_config config1 (100); auto rep (config1.random_representative ()); ASSERT_NE (config1.preconfigured_representatives.end (), std::find (config1.preconfigured_representatives.begin (), config1.preconfigured_representatives.end (), rep)); } @@ -762,7 +757,7 @@ TEST (node, fork_multi_flip) auto type = nano::transport::transport_type::tcp; nano::test::system system; nano::node_flags node_flags; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config, node_flags, type)); node_config.peering_port = system.get_available_port (); @@ -835,13 +830,13 @@ TEST (node, fork_bootstrap_flip) nano::test::system system; nano::test::system system0; nano::test::system system1; - nano::node_config config0{ system.get_available_port (), system0.logging }; + nano::node_config config0{ system.get_available_port () }; config0.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto & node1 = *system0.add_node (config0, node_flags); - nano::node_config config1 (system.get_available_port (), system1.logging); + nano::node_config config1 (system.get_available_port ()); auto & node2 = *system1.add_node (config1, node_flags); system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::block_hash latest = node1.latest (nano::dev::genesis_key.pub); @@ -1247,7 +1242,7 @@ TEST (node, DISABLED_broadcast_elected) auto type = nano::transport::transport_type::tcp; nano::node_flags node_flags; nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 = system.add_node (node_config, node_flags, type); node_config.peering_port = system.get_available_port (); @@ -1373,7 +1368,7 @@ TEST (node, DISABLED_broadcast_elected) TEST (node, rep_self_vote) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.online_weight_minimum = std::numeric_limits::max (); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 = system.add_node (node_config); @@ -1471,10 +1466,10 @@ TEST (node, DISABLED_bootstrap_bulk_push) nano::test::system system; nano::test::system system0; nano::test::system system1; - nano::node_config config0 (system.get_available_port (), system0.logging); + nano::node_config config0 (system.get_available_port ()); config0.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 (system0.add_node (config0)); - nano::node_config config1 (system.get_available_port (), system1.logging); + nano::node_config config1 (system.get_available_port ()); config1.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node1 (system1.add_node (config1)); nano::keypair key0; @@ -1511,7 +1506,7 @@ TEST (node, DISABLED_bootstrap_bulk_push) TEST (node, bootstrap_fork_open) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); auto node0 = system.add_node (node_config); node_config.peering_port = system.get_available_port (); auto node1 = system.add_node (node_config); @@ -1684,7 +1679,7 @@ TEST (node, rep_weight) { nano::test::system system; auto add_node = [&system] { - auto node = std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work); + auto node = std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work); node->start (); system.nodes.push_back (node); return node; @@ -1854,7 +1849,7 @@ TEST (node, rep_remove) ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 0); // Add working node for genesis representative - auto node_genesis_rep = system.add_node (nano::node_config (system.get_available_port (), system.logging)); + auto node_genesis_rep = system.add_node (nano::node_config (system.get_available_port ())); system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); auto channel_genesis_rep (searching_node.network.find_node_id (node_genesis_rep->get_node_id ())); ASSERT_NE (nullptr, channel_genesis_rep); @@ -1865,7 +1860,7 @@ TEST (node, rep_remove) ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); // Start a node for Rep2 and wait until it is connected - auto node_rep2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (system.get_available_port (), system.logging), system.work)); + auto node_rep2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (system.get_available_port ()), system.work)); node_rep2->start (); searching_node.network.tcp_channels.start_tcp (node_rep2->network.endpoint ()); std::shared_ptr channel_rep2; @@ -1906,7 +1901,7 @@ TEST (node, no_voting) { nano::test::system system (1); auto & node0 (*system.nodes[0]); - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.enable_voting = false; system.add_node (node_config); @@ -2230,7 +2225,7 @@ TEST (node, confirm_quorum) TEST (node, local_votes_cache) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; node_config.receive_minimum = nano::dev::constants.genesis_amount; auto & node (*system.add_node (node_config)); @@ -2318,7 +2313,7 @@ TEST (node, local_votes_cache) TEST (node, DISABLED_local_votes_cache_batch) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); ASSERT_GE (node.network_params.voting.max_cache, 2); @@ -2391,7 +2386,7 @@ TEST (node, DISABLED_local_votes_cache_batch) TEST (node, local_votes_cache_generate_new_vote) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -2444,7 +2439,7 @@ TEST (node, local_votes_cache_fork) node_flags.disable_lazy_bootstrap = true; node_flags.disable_legacy_bootstrap = true; node_flags.disable_wallet_bootstrap = true; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config, node_flags)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -2695,7 +2690,7 @@ TEST (node, DISABLED_vote_by_hash_epoch_block_republish) TEST (node, epoch_conflict_confirm) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node0 = *system.add_node (node_config); node_config.peering_port = system.get_available_port (); @@ -3026,7 +3021,7 @@ TEST (node, block_processor_full) nano::node_flags node_flags; node_flags.force_use_write_database_queue = true; node_flags.block_processor_full_size = 3; - auto & node = *system.add_node (nano::node_config (system.get_available_port (), system.logging), node_flags); + auto & node = *system.add_node (nano::node_config (system.get_available_port ()), node_flags); nano::state_block_builder builder; auto send1 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -3071,7 +3066,7 @@ TEST (node, block_processor_half_full) nano::node_flags node_flags; node_flags.block_processor_full_size = 6; node_flags.force_use_write_database_queue = true; - auto & node = *system.add_node (nano::node_config (system.get_available_port (), system.logging), node_flags); + auto & node = *system.add_node (nano::node_config (system.get_available_port ()), node_flags); nano::state_block_builder builder; auto send1 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -3163,7 +3158,7 @@ TEST (node, peers) auto node1 (system.nodes[0]); ASSERT_TRUE (node1->network.empty ()); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); system.nodes.push_back (node2); auto endpoint = node1->network.endpoint (); @@ -3213,7 +3208,7 @@ TEST (node, peer_cache_restart) nano::endpoint_key endpoint_key{ endpoint.address ().to_v6 ().to_bytes (), endpoint.port () }; auto path (nano::unique_path ()); { - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), path, system.logging, system.work)); + auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), path, system.work)); system.nodes.push_back (node2); auto & store = node2->store; { @@ -3233,7 +3228,7 @@ TEST (node, peer_cache_restart) { nano::node_flags node_flags; node_flags.read_only = true; - auto node3 (std::make_shared (system.io_ctx, system.get_available_port (), path, system.logging, system.work, node_flags)); + auto node3 (std::make_shared (system.io_ctx, system.get_available_port (), path, system.work, node_flags)); system.nodes.push_back (node3); // Check cached peers after restart node3->network.start (); @@ -3338,7 +3333,7 @@ TEST (node, bidirectional_tcp) node_flags.disable_legacy_bootstrap = true; node_flags.disable_lazy_bootstrap = true; node_flags.disable_wallet_bootstrap = true; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node1 = system.add_node (node_config, node_flags); node_config.peering_port = system.get_available_port (); @@ -3536,7 +3531,7 @@ TEST (node, rollback_vote_self) TEST (node, rollback_gap_source) { nano::test::system system; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); nano::state_block_builder builder; @@ -3604,7 +3599,7 @@ TEST (node, rollback_gap_source) TEST (node, dependency_graph) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (config); @@ -3802,7 +3797,7 @@ TEST (node, dependency_graph) TEST (node, dependency_graph_frontier) { nano::test::system system; - nano::node_config config (system.get_available_port (), system.logging); + nano::node_config config (system.get_available_port ()); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (config); config.peering_port = system.get_available_port (); @@ -3969,9 +3964,9 @@ namespace nano TEST (node, deferred_dependent_elections) { nano::test::system system; - nano::node_config node_config_1{ system.get_available_port (), system.logging }; + nano::node_config node_config_1{ system.get_available_port () }; node_config_1.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - nano::node_config node_config_2{ system.get_available_port (), system.logging }; + nano::node_config node_config_2{ system.get_available_port () }; node_config_2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags flags; flags.disable_request_loop = true; @@ -4134,7 +4129,7 @@ TEST (node, pruning_automatic) { nano::test::system system{}; - nano::node_config node_config{ system.get_available_port (), system.logging }; + nano::node_config node_config{ system.get_available_port () }; // TODO: remove after allowing pruned voting node_config.enable_voting = false; node_config.max_pruning_age = std::chrono::seconds (1); @@ -4189,7 +4184,7 @@ TEST (node, pruning_age) { nano::test::system system{}; - nano::node_config node_config{ system.get_available_port (), system.logging }; + nano::node_config node_config{ system.get_available_port () }; // TODO: remove after allowing pruned voting node_config.enable_voting = false; @@ -4252,7 +4247,7 @@ TEST (node, pruning_depth) { nano::test::system system{}; - nano::node_config node_config{ system.get_available_port (), system.logging }; + nano::node_config node_config{ system.get_available_port () }; // TODO: remove after allowing pruned voting node_config.enable_voting = false; diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index 9d96fd367f..5c0d83b3b6 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -196,35 +196,6 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.backlog_scan_batch_size, defaults.node.backlog_scan_batch_size); ASSERT_EQ (conf.node.backlog_scan_frequency, defaults.node.backlog_scan_frequency); - ASSERT_EQ (conf.node.logging.bulk_pull_logging_value, defaults.node.logging.bulk_pull_logging_value); - ASSERT_EQ (conf.node.logging.flush, defaults.node.logging.flush); - ASSERT_EQ (conf.node.logging.insufficient_work_logging_value, defaults.node.logging.insufficient_work_logging_value); - ASSERT_EQ (conf.node.logging.ledger_logging_value, defaults.node.logging.ledger_logging_value); - ASSERT_EQ (conf.node.logging.ledger_duplicate_logging_value, defaults.node.logging.ledger_duplicate_logging_value); - ASSERT_EQ (conf.node.logging.log_ipc_value, defaults.node.logging.log_ipc_value); - ASSERT_EQ (conf.node.logging.log_to_cerr_value, defaults.node.logging.log_to_cerr_value); - ASSERT_EQ (conf.node.logging.max_size, defaults.node.logging.max_size); - ASSERT_EQ (conf.node.logging.min_time_between_log_output.count (), defaults.node.logging.min_time_between_log_output.count ()); - ASSERT_EQ (conf.node.logging.network_logging_value, defaults.node.logging.network_logging_value); - ASSERT_EQ (conf.node.logging.network_keepalive_logging_value, defaults.node.logging.network_keepalive_logging_value); - ASSERT_EQ (conf.node.logging.network_message_logging_value, defaults.node.logging.network_message_logging_value); - ASSERT_EQ (conf.node.logging.network_node_id_handshake_logging_value, defaults.node.logging.network_node_id_handshake_logging_value); - ASSERT_EQ (conf.node.logging.network_packet_logging_value, defaults.node.logging.network_packet_logging_value); - ASSERT_EQ (conf.node.logging.network_publish_logging_value, defaults.node.logging.network_publish_logging_value); - ASSERT_EQ (conf.node.logging.network_timeout_logging_value, defaults.node.logging.network_timeout_logging_value); - ASSERT_EQ (conf.node.logging.node_lifetime_tracing_value, defaults.node.logging.node_lifetime_tracing_value); - ASSERT_EQ (conf.node.logging.network_telemetry_logging_value, defaults.node.logging.network_telemetry_logging_value); - ASSERT_EQ (conf.node.logging.network_rejected_logging_value, defaults.node.logging.network_rejected_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); - ASSERT_EQ (conf.node.logging.vote_logging_value, defaults.node.logging.vote_logging_value); - ASSERT_EQ (conf.node.logging.rep_crawler_logging_value, defaults.node.logging.rep_crawler_logging_value); - ASSERT_EQ (conf.node.logging.work_generation_time_value, defaults.node.logging.work_generation_time_value); - ASSERT_EQ (conf.node.websocket_config.enabled, defaults.node.websocket_config.enabled); ASSERT_EQ (conf.node.websocket_config.address, defaults.node.websocket_config.address); ASSERT_EQ (conf.node.websocket_config.port, defaults.node.websocket_config.port); @@ -642,35 +613,6 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.backlog_scan_batch_size, defaults.node.backlog_scan_batch_size); ASSERT_NE (conf.node.backlog_scan_frequency, defaults.node.backlog_scan_frequency); - ASSERT_NE (conf.node.logging.bulk_pull_logging_value, defaults.node.logging.bulk_pull_logging_value); - ASSERT_NE (conf.node.logging.flush, defaults.node.logging.flush); - ASSERT_NE (conf.node.logging.insufficient_work_logging_value, defaults.node.logging.insufficient_work_logging_value); - ASSERT_NE (conf.node.logging.ledger_logging_value, defaults.node.logging.ledger_logging_value); - ASSERT_NE (conf.node.logging.ledger_duplicate_logging_value, defaults.node.logging.ledger_duplicate_logging_value); - ASSERT_NE (conf.node.logging.log_ipc_value, defaults.node.logging.log_ipc_value); - ASSERT_NE (conf.node.logging.log_to_cerr_value, defaults.node.logging.log_to_cerr_value); - ASSERT_NE (conf.node.logging.max_size, defaults.node.logging.max_size); - ASSERT_NE (conf.node.logging.min_time_between_log_output.count (), defaults.node.logging.min_time_between_log_output.count ()); - ASSERT_NE (conf.node.logging.network_logging_value, defaults.node.logging.network_logging_value); - ASSERT_NE (conf.node.logging.network_keepalive_logging_value, defaults.node.logging.network_keepalive_logging_value); - ASSERT_NE (conf.node.logging.network_message_logging_value, defaults.node.logging.network_message_logging_value); - ASSERT_NE (conf.node.logging.network_node_id_handshake_logging_value, defaults.node.logging.network_node_id_handshake_logging_value); - ASSERT_NE (conf.node.logging.network_telemetry_logging_value, defaults.node.logging.network_telemetry_logging_value); - ASSERT_NE (conf.node.logging.network_rejected_logging_value, defaults.node.logging.network_rejected_logging_value); - ASSERT_NE (conf.node.logging.network_packet_logging_value, defaults.node.logging.network_packet_logging_value); - ASSERT_NE (conf.node.logging.network_publish_logging_value, defaults.node.logging.network_publish_logging_value); - ASSERT_NE (conf.node.logging.network_timeout_logging_value, defaults.node.logging.network_timeout_logging_value); - 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); - ASSERT_NE (conf.node.logging.vote_logging_value, defaults.node.logging.vote_logging_value); - ASSERT_NE (conf.node.logging.rep_crawler_logging_value, defaults.node.logging.rep_crawler_logging_value); - ASSERT_NE (conf.node.logging.work_generation_time_value, defaults.node.logging.work_generation_time_value); - ASSERT_NE (conf.node.websocket_config.enabled, defaults.node.websocket_config.enabled); ASSERT_NE (conf.node.websocket_config.address, defaults.node.websocket_config.address); ASSERT_NE (conf.node.websocket_config.port, defaults.node.websocket_config.port); diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index c9efc500a3..6823c1f72d 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 44e726a8b9..1c429ca3a9 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include #include @@ -90,8 +89,6 @@ TEST (work, cancel_many) TEST (work, opencl) { - nano::logging logging; - logging.init (nano::unique_path ()); nano::nlogger logger; bool error (false); nano::opencl_environment environment (error); diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 102cb2e931..84fa0e1a6a 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -50,7 +50,6 @@ add_library( lmdbconfig.cpp locks.hpp locks.cpp - logger_mt.hpp logging.hpp logging.cpp logging_enums.hpp @@ -120,8 +119,6 @@ target_link_libraries( Boost::asio Boost::circular_buffer Boost::dll - Boost::log_setup - Boost::log Boost::multiprecision Boost::program_options Boost::stacktrace) diff --git a/nano/lib/logger_mt.hpp b/nano/lib/logger_mt.hpp deleted file mode 100644 index 9afd47842a..0000000000 --- a/nano/lib/logger_mt.hpp +++ /dev/null @@ -1,139 +0,0 @@ -#pragma once - -#include -#include - -#include -#include -#include - -#include -#include -#include - -namespace nano -{ -enum class severity_level -{ - normal = 0, - error -}; -} - -// Attribute value tag type -struct severity_tag; - -inline boost::log::formatting_ostream & operator<< (boost::log::formatting_ostream & strm, boost::log::to_log_manip const & manip) -{ - // Needs to match order in the severity_level enum - static std::array strings = { - "", - "Error: " - }; - - nano::severity_level level = manip.get (); - debug_assert (static_cast (level) < strings.size ()); - strm << strings[static_cast (level)]; - return strm; -} - -namespace nano -{ -// A wrapper around a boost logger object to allow minimum -// time spaced output to prevent logging happening too quickly. -class logger_mt -{ -private: - void add_to_stream (boost::log::record_ostream & stream) - { - } - - template - void add_to_stream (boost::log::record_ostream & stream, const LogItem & first_log_item, LogItems &&... remainder_log_items) - { - stream << first_log_item; - add_to_stream (stream, remainder_log_items...); - } - - template - void output (nano::severity_level severity_level, LogItems &&... log_items) - { - boost::log::record rec = boost_logger_mt.open_record (boost::log::keywords::severity = severity_level); - if (rec) - { - boost::log::record_ostream strm (rec); - add_to_stream (strm, std::forward (log_items)...); - strm.flush (); - boost_logger_mt.push_record (std::move (rec)); - } - } - -public: - logger_mt () = default; - - /** - * @param min_log_delta_a The minimum time between successive output - */ - explicit logger_mt (std::chrono::milliseconds const & min_log_delta_a) : - min_log_delta (min_log_delta_a) - { - } - - /* - * @param log_items A collection of objects with overloaded operator<< to be output to the log file - * @params severity_level The severity level that this log message should have. - */ - template - void always_log (nano::severity_level severity_level, LogItems &&... log_items) - { - output (severity_level, std::forward (log_items)...); - } - - /* - * @param log_items A collection of objects with overloaded operator<< to be output to the log file. - */ - template - void always_log (LogItems &&... log_items) - { - always_log (nano::severity_level::normal, std::forward (log_items)...); - } - - /* - * @param log_items Output to the log file if the last write was over min_log_delta time ago. - * @params severity_level The severity level that this log message should have. - * @return true if nothing was logged - */ - template - bool try_log (nano::severity_level severity_level, LogItems &&... log_items) - { - auto error (true); - auto time_now = std::chrono::steady_clock::now (); - nano::unique_lock lk (last_log_time_mutex); - if (((time_now - last_log_time) > min_log_delta) || last_log_time == std::chrono::steady_clock::time_point{}) - { - last_log_time = time_now; - lk.unlock (); - output (severity_level, std::forward (log_items)...); - error = false; - } - return error; - } - - /* - * @param log_items Output to the log file if the last write was over min_log_delta time ago. - * @return true if nothing was logged - */ - template - bool try_log (LogItems &&... log_items) - { - return try_log (nano::severity_level::normal, std::forward (log_items)...); - } - - std::chrono::milliseconds min_log_delta{ 0 }; - -private: - nano::mutex last_log_time_mutex; - std::chrono::steady_clock::time_point last_log_time; - boost::log::sources::severity_logger_mt boost_logger_mt; -}; -} diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index dc16ead8d3..08b5108384 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -84,8 +84,6 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag } if (!error) { - config.node.logging.init (data_path); - auto tls_config (std::make_shared ()); error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index c23b4ec9ee..bee3d44e06 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1124,10 +1124,8 @@ int main (int argc, char * const * argv) boost::asio::io_context io_ctx1; boost::asio::io_context io_ctx2; nano::work_pool work{ network_params.network, std::numeric_limits::max () }; - nano::logging logging; auto path1 (nano::unique_path ()); auto path2 (nano::unique_path ()); - logging.init (path1); std::vector config_overrides; auto config (vm.find ("config")); if (config != vm.end ()) @@ -1882,13 +1880,6 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_sys_logging")) { -#ifdef BOOST_WINDOWS - if (!nano::event_log_reg_entry_exists () && !nano::is_windows_elevated ()) - { - std::cerr << "The event log requires the HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\EventLog\\Nano\\Nano registry entry, run again as administator to create it.\n"; - return 1; - } -#endif auto inactive_node = nano::default_inactive_node (data_path, vm); inactive_node->node->nlogger.critical ({}, "Testing system logger (CRITICAL)"); inactive_node->node->nlogger.error ({}, "Testing system logger (ERROR)"); diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp index 84164c0a3a..1238c95ce3 100644 --- a/nano/nano_rpc/entry.cpp +++ b/nano/nano_rpc/entry.cpp @@ -12,27 +12,11 @@ #include #include -#include -#include +#include #include namespace { -void logging_init (std::filesystem::path const & application_path_a) -{ - static std::atomic_flag logging_already_added = ATOMIC_FLAG_INIT; - if (!logging_already_added.test_and_set ()) - { - boost::log::add_common_attributes (); - auto path = application_path_a / "log"; - - uintmax_t max_size{ 128 * 1024 * 1024 }; - uintmax_t rotation_size{ 4 * 1024 * 1024 }; - bool flush{ true }; - boost::log::add_file_log (boost::log::keywords::target = path, boost::log::keywords::file_name = path / "rpc_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 = "[%TimeStamp%]: %Message%"); - } -} - volatile sig_atomic_t sig_int_or_term = 0; nano::nlogger nlogger{ "rpc_daemon" }; @@ -53,8 +37,6 @@ void run (std::filesystem::path const & data_path, std::vector cons auto error = nano::read_rpc_config_toml (data_path, rpc_config, config_overrides); if (!error) { - logging_init (data_path); - auto tls_config (std::make_shared ()); error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 0008cedc7d..04e55e14d2 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -109,8 +109,6 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: { nano::set_use_memory_pools (config.node.use_memory_pools); - config.node.logging.init (data_path); - auto tls_config (std::make_shared ()); error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); if (error) diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 52d7eec664..7918388016 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -110,8 +110,6 @@ add_library( ipc/ipc_server.cpp json_handler.hpp json_handler.cpp - logging.hpp - logging.cpp make_store.hpp make_store.cpp network.hpp @@ -204,8 +202,6 @@ target_link_libraries( argon2 lmdb Boost::beast - Boost::log_setup - Boost::log Boost::program_options Boost::stacktrace Boost::system diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 7b455fb76c..f5667628ff 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -174,7 +174,7 @@ bool nano::block_processor::should_log () auto now (std::chrono::steady_clock::now ()); if (next_log < now) { - next_log = now + (node.config.logging.timing_logging () ? std::chrono::seconds (2) : std::chrono::seconds (15)); + next_log = now + std::chrono::seconds (15); result = true; } return result; diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index cb5947a320..8e2457c95f 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -165,20 +165,17 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end } else { - if (this_l->node.config.logging.network_logging ()) + switch (ec.value ()) { - switch (ec.value ()) - { - default: - this_l->node.nlogger.debug (nano::log::type::bootstrap, "Error initiating bootstrap connection to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); - break; - case boost::system::errc::connection_refused: - case boost::system::errc::operation_canceled: - case boost::system::errc::timed_out: - case 995: // Windows The I/O operation has been aborted because of either a thread exit or an application request - case 10061: // Windows No connection could be made because the target machine actively refused it - break; - } + default: + this_l->node.nlogger.debug (nano::log::type::bootstrap, "Error initiating bootstrap connection to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + break; + case boost::system::errc::connection_refused: + case boost::system::errc::operation_canceled: + case boost::system::errc::timed_out: + case 995: // Windows The I/O operation has been aborted because of either a thread exit or an application request + case 10061: // Windows No connection could be made because the target machine actively refused it + break; } } --this_l->connections_count; diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 44569ebbe4..8bcb25756a 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -1,7 +1,5 @@ -#include #include #include -#include #include #include #include diff --git a/nano/node/confirmation_height_bounded.hpp b/nano/node/confirmation_height_bounded.hpp index c42cd61397..ee453769cd 100644 --- a/nano/node/confirmation_height_bounded.hpp +++ b/nano/node/confirmation_height_bounded.hpp @@ -12,8 +12,6 @@ namespace nano { class ledger; -class logging; -class logger_mt; class write_database_queue; class write_guard; diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index 6e937c54c1..a3c9b325c7 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -1,4 +1,3 @@ -#include #include #include #include diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index c7edd9cdbc..4b7f9fffe5 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -1,7 +1,5 @@ -#include #include #include -#include #include #include #include diff --git a/nano/node/confirmation_height_unbounded.hpp b/nano/node/confirmation_height_unbounded.hpp index 9bee338c4d..2264d6fa06 100644 --- a/nano/node/confirmation_height_unbounded.hpp +++ b/nano/node/confirmation_height_unbounded.hpp @@ -13,8 +13,6 @@ namespace nano { class ledger; -class logging; -class logger_mt; class write_database_queue; class write_guard; diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index 2a3e4a0185..b629fc72e2 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -23,8 +23,6 @@ #include -using namespace boost::log; - namespace { /** diff --git a/nano/node/logging.cpp b/nano/node/logging.cpp deleted file mode 100644 index 5dcfb9f816..0000000000 --- a/nano/node/logging.cpp +++ /dev/null @@ -1,344 +0,0 @@ -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_WINDOWS -#else -#define BOOST_LOG_USE_NATIVE_SYSLOG -#include -#endif - -BOOST_LOG_ATTRIBUTE_KEYWORD (severity, "Severity", nano::severity_level) - -boost::shared_ptr> nano::logging::file_sink; -std::atomic_flag nano::logging::logging_already_added ATOMIC_FLAG_INIT; - -void nano::logging::init (std::filesystem::path const & application_path_a) -{ - if (!logging_already_added.test_and_set ()) - { - boost::log::add_common_attributes (); - auto format = boost::log::expressions::stream << boost::log::expressions::attr ("Severity") << boost::log::expressions::smessage; - auto format_with_timestamp = boost::log::expressions::stream << "[" << boost::log::expressions::attr ("TimeStamp") << "]: " << boost::log::expressions::attr ("Severity") << boost::log::expressions::smessage; - - if (log_to_cerr ()) - { - boost::log::add_console_log (std::cerr, boost::log::keywords::format = format_with_timestamp); - } - -#ifdef BOOST_WINDOWS -#else - static auto sys_sink = boost::make_shared> (boost::log::keywords::facility = boost::log::sinks::syslog::user, boost::log::keywords::use_impl = boost::log::sinks::syslog::impl_types::native); - sys_sink->set_formatter (format); - - // Currently only mapping sys log errors - boost::log::sinks::syslog::custom_severity_mapping mapping ("Severity"); - mapping[nano::severity_level::error] = boost::log::sinks::syslog::error; - sys_sink->locked_backend ()->set_severity_mapper (mapping); - - // Only allow messages or error or greater severity to the sys log - sys_sink->set_filter (severity >= nano::severity_level::error); - boost::log::core::get ()->add_sink (sys_sink); -#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"; - if (stable_log_filename) - { -#if BOOST_VERSION >= 107000 - auto const file_name = path / "node.log"; - // 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 = file_name, - 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); - - if (!std::filesystem::exists (file_name)) - { - // Create temp stream to first create the file - std::ofstream stream (file_name.string ()); - } - - // Set permissions before opening otherwise Windows only has read permissions - nano::set_secure_perm_file (file_name); - -#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); - } - - struct exception_handler - { - void operator() (std::exception const & e) const - { - std::cerr << "Logging exception: " << e.what () << std::endl; - } - }; - - boost::log::core::get ()->set_exception_handler (boost::log::make_exception_handler (exception_handler ())); - } - //clang-format on -} - -void nano::logging::release_file_sink () -{ - if (logging_already_added.test_and_set ()) - { - boost::log::core::get ()->remove_sink (nano::logging::file_sink); - nano::logging::file_sink.reset (); - logging_already_added.clear (); - } -} - -nano::error nano::logging::serialize_toml (nano::tomlconfig & toml) const -{ - toml.put ("ledger", ledger_logging_value, "Log ledger related messages.\ntype:bool"); - toml.put ("ledger_duplicate", ledger_duplicate_logging_value, "Log when a duplicate block is attempted inserted into the ledger.\ntype:bool"); - toml.put ("ledger_rollback", election_fork_tally_logging_value, "Log when a block is replaced in the ledger.\ntype:bool"); - toml.put ("vote", vote_logging_value, "Vote logging. Enabling this option leads to a high volume.\nof log messages which may affect node performance.\ntype:bool"); - toml.put ("rep_crawler", rep_crawler_logging_value, "Rep crawler logging. Enabling this option leads to a high volume.\nof log messages which may affect node performance.\ntype:bool"); - toml.put ("election_expiration", election_expiration_tally_logging_value, "Log election tally on expiration.\ntype:bool"); - toml.put ("election_fork", election_fork_tally_logging_value, "Log election tally when more than one block is seen.\ntype:bool"); - toml.put ("network", network_logging_value, "Log network related messages.\ntype:bool"); - toml.put ("network_timeout", network_timeout_logging_value, "Log TCP timeouts.\ntype:bool"); - toml.put ("network_message", network_message_logging_value, "Log network errors and message details.\ntype:bool"); - toml.put ("network_publish", network_publish_logging_value, "Log publish related network messages.\ntype:bool"); - toml.put ("network_packet", network_packet_logging_value, "Log network packet activity.\ntype:bool"); - toml.put ("network_keepalive", network_keepalive_logging_value, "Log keepalive related messages.\ntype:bool"); - toml.put ("network_node_id_handshake", network_node_id_handshake_logging_value, "Log node-id handshake related messages.\ntype:bool"); - toml.put ("network_telemetry", network_telemetry_logging_value, "Log telemetry related messages.\ntype:bool"); - toml.put ("network_rejected", network_rejected_logging_value, "Log message when a connection is rejected.\ntype:bool"); - toml.put ("node_lifetime_tracing", node_lifetime_tracing_value, "Log node startup and shutdown messages.\ntype:bool"); - toml.put ("insufficient_work", insufficient_work_logging_value, "Log if insufficient work is detected.\ntype:bool"); - toml.put ("log_ipc", log_ipc_value, "Log IPC related activity.\ntype:bool"); - toml.put ("bulk_pull", bulk_pull_logging_value, "Log bulk pull errors and messages.\ntype:bool"); - toml.put ("work_generation_time", work_generation_time_value, "Log work generation timing information.\ntype:bool"); - toml.put ("upnp_details", upnp_details_logging_value, "Log UPNP discovery details..\nWarning: this may include information.\nabout discovered devices, such as product identification. Please review before sharing logs.\ntype:bool"); - toml.put ("timing", timing_logging_value, "Log detailed timing information for various node operations.\ntype:bool"); - toml.put ("active_update", active_update_value, "Log when a block is updated while in active transactions.\ntype:bool"); - toml.put ("election_result", election_result_logging_value, "Log election result when cleaning up election from active election container.\ntype:bool"); - toml.put ("log_to_cerr", log_to_cerr_value, "Log to standard error in addition to the log file. Not recommended for production systems.\ntype:bool"); - toml.put ("max_size", max_size, "Maximum log file size in bytes.\ntype:uint64"); - toml.put ("rotation_size", rotation_size, "Log file rotation size in character count.\ntype:uint64"); - 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 (); -} - -nano::error nano::logging::deserialize_toml (nano::tomlconfig & toml) -{ - toml.get ("ledger", ledger_logging_value); - toml.get ("ledger_duplicate", ledger_duplicate_logging_value); - toml.get ("ledger_rollback", ledger_rollback_logging_value); - toml.get ("vote", vote_logging_value); - toml.get ("rep_crawler", rep_crawler_logging_value); - toml.get ("election_expiration", election_expiration_tally_logging_value); - toml.get ("election_fork", election_fork_tally_logging_value); - toml.get ("network", network_logging_value); - toml.get ("network_timeout", network_timeout_logging_value); - toml.get ("network_message", network_message_logging_value); - toml.get ("network_publish", network_publish_logging_value); - toml.get ("network_packet", network_packet_logging_value); - toml.get ("network_keepalive", network_keepalive_logging_value); - toml.get ("network_node_id_handshake", network_node_id_handshake_logging_value); - toml.get ("network_telemetry_logging", network_telemetry_logging_value); - toml.get ("network_rejected_logging", network_rejected_logging_value); - toml.get ("node_lifetime_tracing", node_lifetime_tracing_value); - toml.get ("insufficient_work", insufficient_work_logging_value); - toml.get ("log_ipc", log_ipc_value); - toml.get ("bulk_pull", bulk_pull_logging_value); - toml.get ("work_generation_time", work_generation_time_value); - toml.get ("upnp_details", upnp_details_logging_value); - toml.get ("timing", timing_logging_value); - toml.get ("active_update", active_update_value); - toml.get ("election_result", election_result_logging_value); - toml.get ("log_to_cerr", log_to_cerr_value); - toml.get ("flush", flush); - toml.get ("single_line_record", single_line_record_value); - toml.get ("max_size", max_size); - toml.get ("rotation_size", rotation_size); - 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 (); -} - -bool nano::logging::ledger_logging () const -{ - return ledger_logging_value; -} - -bool nano::logging::ledger_duplicate_logging () const -{ - return ledger_logging () && ledger_duplicate_logging_value; -} - -bool nano::logging::ledger_rollback_logging () const -{ - return ledger_rollback_logging_value; -} - -bool nano::logging::vote_logging () const -{ - return vote_logging_value; -} - -bool nano::logging::rep_crawler_logging () const -{ - return rep_crawler_logging_value; -} - -bool nano::logging::election_expiration_tally_logging () const -{ - return election_expiration_tally_logging_value; -} - -bool nano::logging::election_fork_tally_logging () const -{ - return election_fork_tally_logging_value; -} - -bool nano::logging::network_logging () const -{ - return network_logging_value; -} - -bool nano::logging::network_timeout_logging () const -{ - return network_logging () && network_timeout_logging_value; -} - -bool nano::logging::network_message_logging () const -{ - return network_logging () && network_message_logging_value; -} - -bool nano::logging::network_publish_logging () const -{ - return network_logging () && network_publish_logging_value; -} - -bool nano::logging::network_packet_logging () const -{ - return network_logging () && network_packet_logging_value; -} - -bool nano::logging::network_keepalive_logging () const -{ - return network_logging () && network_keepalive_logging_value; -} - -bool nano::logging::network_node_id_handshake_logging () const -{ - return network_logging () && network_node_id_handshake_logging_value; -} - -bool nano::logging::network_telemetry_logging () const -{ - return network_logging () && network_telemetry_logging_value; -} - -bool nano::logging::network_rejected_logging () const -{ - return network_logging () && network_rejected_logging_value; -} - -bool nano::logging::node_lifetime_tracing () const -{ - return node_lifetime_tracing_value; -} - -bool nano::logging::insufficient_work_logging () const -{ - return network_logging () && insufficient_work_logging_value; -} - -bool nano::logging::log_ipc () const -{ - return network_logging () && log_ipc_value; -} - -bool nano::logging::bulk_pull_logging () const -{ - return network_logging () && bulk_pull_logging_value; -} - -bool nano::logging::callback_logging () const -{ - return network_logging (); -} - -bool nano::logging::work_generation_time () const -{ - return work_generation_time_value; -} - -bool nano::logging::upnp_details_logging () const -{ - return upnp_details_logging_value; -} - -bool nano::logging::timing_logging () const -{ - return timing_logging_value; -} - -bool nano::logging::active_update_logging () const -{ - return active_update_value; -} - -bool nano::logging::election_result_logging () const -{ - return election_result_logging_value; -} - -bool nano::logging::log_to_cerr () const -{ - return log_to_cerr_value; -} - -bool nano::logging::single_line_record () const -{ - return single_line_record_value; -} diff --git a/nano/node/logging.hpp b/nano/node/logging.hpp deleted file mode 100644 index e8f206a51e..0000000000 --- a/nano/node/logging.hpp +++ /dev/null @@ -1,105 +0,0 @@ -#pragma once - -#include - -#include -#include - -#include -#include -#include - -#define FATAL_LOG_PREFIX "FATAL ERROR: " - -namespace boost -{ -BOOST_LOG_OPEN_NAMESPACE -namespace sinks -{ - class text_file_backend; - - template - class synchronous_sink; -} - -BOOST_LOG_CLOSE_NAMESPACE - -} - -namespace nano -{ -class tomlconfig; -class logging final -{ -public: - nano::error serialize_toml (nano::tomlconfig &) const; - nano::error deserialize_toml (nano::tomlconfig &); - bool ledger_logging () const; - bool ledger_duplicate_logging () const; - bool ledger_rollback_logging () const; - bool vote_logging () const; - bool rep_crawler_logging () const; - bool election_fork_tally_logging () const; - bool election_expiration_tally_logging () const; - bool network_logging () const; - bool network_timeout_logging () const; - bool network_message_logging () const; - bool network_publish_logging () const; - bool network_packet_logging () const; - bool network_keepalive_logging () const; - bool network_node_id_handshake_logging () const; - bool network_telemetry_logging () const; - bool network_rejected_logging () const; - bool node_lifetime_tracing () const; - bool insufficient_work_logging () const; - bool upnp_details_logging () const; - bool timing_logging () const; - bool log_ipc () const; - bool bulk_pull_logging () const; - bool callback_logging () const; - bool work_generation_time () const; - bool active_update_logging () const; - bool election_result_logging () const; - bool log_to_cerr () const; - bool single_line_record () const; - void init (std::filesystem::path const &); - - bool ledger_logging_value{ false }; - bool ledger_duplicate_logging_value{ false }; - bool ledger_rollback_logging_value{ false }; - bool vote_logging_value{ false }; - bool rep_crawler_logging_value{ false }; - bool election_fork_tally_logging_value{ false }; - bool election_expiration_tally_logging_value{ false }; - bool network_logging_value{ true }; - bool network_timeout_logging_value{ false }; - bool network_message_logging_value{ false }; - bool network_publish_logging_value{ false }; - bool network_packet_logging_value{ false }; - bool network_keepalive_logging_value{ false }; - bool network_node_id_handshake_logging_value{ false }; - bool network_telemetry_logging_value{ false }; - bool network_rejected_logging_value{ false }; - bool node_lifetime_tracing_value{ false }; - bool insufficient_work_logging_value{ true }; - bool log_ipc_value{ true }; - bool bulk_pull_logging_value{ false }; - bool work_generation_time_value{ true }; - bool upnp_details_logging_value{ false }; - bool timing_logging_value{ false }; - bool active_update_value{ false }; - bool election_result_logging_value{ false }; - bool log_to_cerr_value{ false }; - 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 (); - -private: - static boost::shared_ptr> file_sink; - static std::atomic_flag logging_already_added; -}; -} diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 679ccf2d90..f6cb17ebd1 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -132,8 +132,8 @@ nano::keypair nano::load_or_create_node_id (std::filesystem::path const & applic } } -nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, std::filesystem::path const & application_path_a, nano::logging const & logging_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) : - node (io_ctx_a, application_path_a, nano::node_config (peering_port_a, logging_a), work_a, flags_a, seq) +nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, std::filesystem::path const & application_path_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) : + node (io_ctx_a, application_path_a, nano::node_config (peering_port_a), work_a, flags_a, seq) { } @@ -150,7 +150,6 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons flags (flags_a), work (work_a), distributed_work (*this), - logger (config_a.logging.min_time_between_log_output), store_impl (nano::make_store (nlogger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), store (*store_impl), unchecked{ stats, flags.disable_block_processor_unchecked_deletion }, @@ -1510,8 +1509,6 @@ nano::node_wrapper::node_wrapper (std::filesystem::path const & path_a, std::fil auto & node_config = daemon_config.node; node_config.peering_port = 24000; - node_config.logging.max_size = std::numeric_limits::max (); - node_config.logging.init (path_a); node = std::make_shared (*io_context, path_a, node_config, work, node_flags_a); } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 4b18661301..3e1324bd9a 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include #include @@ -71,7 +70,7 @@ outbound_bandwidth_limiter::config outbound_bandwidth_limiter_config (node_confi class node final : public std::enable_shared_from_this { public: - node (boost::asio::io_context &, uint16_t, std::filesystem::path const &, nano::logging const &, nano::work_pool &, nano::node_flags = nano::node_flags (), unsigned seq = 0); + node (boost::asio::io_context &, uint16_t, std::filesystem::path const &, nano::work_pool &, nano::node_flags = nano::node_flags (), unsigned seq = 0); node (boost::asio::io_context &, std::filesystem::path const &, nano::node_config const &, nano::work_pool &, nano::node_flags = nano::node_flags (), unsigned seq = 0); ~node (); @@ -153,7 +152,6 @@ class node final : public std::enable_shared_from_this nano::node_flags flags; nano::work_pool & work; nano::distributed_work_factory distributed_work; - nano::logger_mt logger; std::unique_ptr store_impl; nano::store::component & store; nano::unchecked_map unchecked; diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 2453c2c24d..61179c685c 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -21,15 +21,14 @@ std::string const default_test_peer_network = nano::get_env_or_default ("NANO_DE } nano::node_config::node_config (nano::network_params & network_params) : - node_config (std::nullopt, nano::logging (), network_params) + node_config (std::nullopt, network_params) { } -nano::node_config::node_config (const std::optional & peering_port_a, nano::logging const & logging_a, nano::network_params & network_params) : +nano::node_config::node_config (const std::optional & peering_port_a, nano::network_params & network_params) : network_params{ network_params }, peering_port{ peering_port_a }, hinted_scheduler{ network_params.network }, - logging{ logging_a }, websocket_config{ network_params.network }, ipc_config{ network_params.network }, external_address{ boost::asio::ip::address_v6{}.to_string () } @@ -168,10 +167,6 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const callback_l.put ("target", callback_target, "Callback target path.\ntype:string,uri"); toml.put_child ("httpcallback", callback_l); - nano::tomlconfig logging_l; - logging.serialize_toml (logging_l); - toml.put_child ("logging", logging_l); - nano::tomlconfig websocket_l; websocket_config.serialize_toml (websocket_l); toml.put_child ("websocket", websocket_l); @@ -223,12 +218,6 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) callback_l.get ("target", callback_target); } - if (toml.has_key ("logging")) - { - auto logging_l (toml.get_required_child ("logging")); - logging.deserialize_toml (logging_l); - } - if (toml.has_key ("websocket")) { auto websocket_config_l (toml.get_required_child ("websocket")); diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 89221c53c7..c4f8a9693b 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -10,7 +10,6 @@ #include #include #include -#include #include #include #include @@ -40,7 +39,7 @@ class node_config { public: node_config (nano::network_params & network_params = nano::dev::network_params); - node_config (const std::optional &, nano::logging const &, nano::network_params & network_params = nano::dev::network_params); + node_config (const std::optional &, nano::network_params & network_params = nano::dev::network_params); nano::error serialize_toml (nano::tomlconfig &) const; nano::error deserialize_toml (nano::tomlconfig &); @@ -52,7 +51,6 @@ class node_config std::optional peering_port{}; nano::scheduler::optimistic_config optimistic_scheduler; nano::scheduler::hinted_config hinted_scheduler; - nano::logging logging; std::vector> work_peers; std::vector> secondary_work_peers{ { "127.0.0.1", 8076 } }; /* Default of nano-pow-server */ std::vector preconfigured_peers; diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 01d169ab04..522cba1aba 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -1,4 +1,4 @@ -#include + #include #include #include @@ -62,7 +62,8 @@ void nano::vote_processor::process_loop () condition.notify_all (); log_this_iteration = false; - if (config.logging.network_logging () && votes_l.size () > 50) + // TODO: This is a temporary measure to prevent spamming the logs until we can implement a better solution + if (votes_l.size () > 1024 * 4) { /* * Only log the timing information for this iteration if diff --git a/nano/rpc/rpc_connection.cpp b/nano/rpc/rpc_connection.cpp index 4d0232bf63..f8c4b34b59 100644 --- a/nano/rpc/rpc_connection.cpp +++ b/nano/rpc/rpc_connection.cpp @@ -1,6 +1,5 @@ #include #include -#include #include #include #include diff --git a/nano/rpc/rpc_connection.hpp b/nano/rpc/rpc_connection.hpp index e0f18367ff..da37b47e6d 100644 --- a/nano/rpc/rpc_connection.hpp +++ b/nano/rpc/rpc_connection.hpp @@ -19,7 +19,6 @@ using socket_type = boost::asio::basic_stream_socket #include #include -#include #include #include #include diff --git a/nano/rpc/rpc_handler.hpp b/nano/rpc/rpc_handler.hpp index 92850497cc..b8fd6093ce 100644 --- a/nano/rpc/rpc_handler.hpp +++ b/nano/rpc/rpc_handler.hpp @@ -11,7 +11,6 @@ namespace nano { class rpc_config; class rpc_handler_interface; -class logger_mt; class rpc_handler_request_params; class rpc_handler : public std::enable_shared_from_this diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 056d05a1b7..fff4b0d3ac 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -1677,7 +1677,7 @@ TEST (rpc, keepalive) { nano::test::system system; auto node0 = add_ipc_enabled_node (system); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); node1->start (); system.nodes.push_back (node1); auto const rpc_ctx = add_rpc (system, node0); @@ -5376,7 +5376,6 @@ TEST (rpc, block_confirm_confirmed) config.callback_address = "localhost"; config.callback_port = system.get_available_port (); config.callback_target = "/"; - config.logging.init (path); auto node = add_ipc_enabled_node (system, config); { auto transaction (node->store.tx_begin_read ()); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index db710f87ba..141ae86cc7 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -89,7 +89,7 @@ TEST (system, receive_while_synchronizing) uint32_t count (1000); system.generate_mass_activity (count, *system.nodes[0]); nano::keypair key; - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); ASSERT_FALSE (node1->init_error ()); auto wallet (node1->wallets.create (1)); wallet->insert_adhoc (nano::dev::genesis_key.prv); // For voting @@ -2123,7 +2123,7 @@ TEST (node, wallet_create_block_confirm_conflicts) { nano::test::system system; nano::block_builder builder; - nano::node_config node_config (system.get_available_port (), system.logging); + nano::node_config node_config (system.get_available_port ()); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); auto const num_blocks = 10000; diff --git a/nano/test_common/CMakeLists.txt b/nano/test_common/CMakeLists.txt index 337d34211d..6271377f45 100644 --- a/nano/test_common/CMakeLists.txt +++ b/nano/test_common/CMakeLists.txt @@ -15,7 +15,7 @@ add_library( testutil.hpp testutil.cpp) -target_link_libraries(test_common node gtest Boost::log_setup Boost::log) +target_link_libraries(test_common node gtest) include_directories(${CMAKE_SOURCE_DIR}/submodules) include_directories(${CMAKE_SOURCE_DIR}/submodules/gtest/googletest/include) diff --git a/nano/test_common/ledger.hpp b/nano/test_common/ledger.hpp index 704ff0b1c7..09c5d1bfa4 100644 --- a/nano/test_common/ledger.hpp +++ b/nano/test_common/ledger.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp index 3241afca61..1d584ac185 100644 --- a/nano/test_common/network.cpp +++ b/nano/test_common/network.cpp @@ -26,7 +26,7 @@ std::shared_ptr nano::test::establish_tcp (nano::t std::shared_ptr nano::test::add_outer_node (nano::test::system & system_a, nano::node_flags flags_a) { - auto outer_node = std::make_shared (system_a.io_ctx, system_a.get_available_port (), nano::unique_path (), system_a.logging, system_a.work, flags_a); + auto outer_node = std::make_shared (system_a.io_ctx, system_a.get_available_port (), nano::unique_path (), system_a.work, flags_a); outer_node->start (); system_a.nodes.push_back (outer_node); return outer_node; diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 650ba3eed0..eff5f455b5 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -132,7 +132,6 @@ nano::test::system::system () { deadline_scaling_factor = std::stod (scale_str); } - logging.init (nano::unique_path ()); } nano::test::system::system (uint16_t count_a, nano::transport::transport_type type_a, nano::node_flags flags_a) : @@ -563,7 +562,7 @@ void nano::test::system::stop () nano::node_config nano::test::system::default_config () { - nano::node_config config{ get_available_port (), logging }; + nano::node_config config{ get_available_port () }; return config; } diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index f0f31afd92..278492edf4 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -66,7 +66,6 @@ namespace test public: boost::asio::io_context io_ctx; std::vector> nodes; - nano::logging logging; nano::stats stats; nano::nlogger nlogger; nano::work_pool work{ nano::dev::network_params.network, std::max (nano::hardware_concurrency (), 1u) }; diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index 3203fdfb3e..766d6da64d 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -7,8 +7,6 @@ #include #include -#include -#include #include #include @@ -136,54 +134,6 @@ namespace test { class system; - class stringstream_mt_sink : public boost::iostreams::sink - { - public: - stringstream_mt_sink () = default; - stringstream_mt_sink (stringstream_mt_sink const & sink) - { - nano::lock_guard guard{ mutex }; - ss << sink.ss.str (); - } - - std::streamsize write (char const * string_to_write, std::streamsize size) - { - nano::lock_guard guard{ mutex }; - ss << std::string (string_to_write, size); - return size; - } - - std::string str () - { - nano::lock_guard guard{ mutex }; - return ss.str (); - } - - private: - mutable nano::mutex mutex; - std::stringstream ss; - }; - - class boost_log_cerr_redirect - { - public: - boost_log_cerr_redirect (std::streambuf * new_buffer) : - old (std::cerr.rdbuf (new_buffer)) - { - console_sink = (boost::log::add_console_log (std::cerr, boost::log::keywords::format = "%Message%")); - } - - ~boost_log_cerr_redirect () - { - std::cerr.rdbuf (old); - boost::log::core::get ()->remove_sink (console_sink); - } - - private: - std::streambuf * old; - boost::shared_ptr> console_sink; - }; - class cout_redirect { public: From 11eadb000c68e24306967e74a758bb78a3bae901 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 12 Jan 2024 18:49:26 +0100 Subject: [PATCH 009/190] Generate sample log config --- CMakeLists.txt | 1 + nano/nano_node/CMakeLists.txt | 4 +++- nano/node/cli.cpp | 8 +++++++- 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cbdb7bf6cc..6218ab5fdb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -757,6 +757,7 @@ endif() if(NANO_GUI OR RAIBLOCKS_GUI) install(FILES ${PROJECT_BINARY_DIR}/config-node.toml.sample DESTINATION .) install(FILES ${PROJECT_BINARY_DIR}/config-rpc.toml.sample DESTINATION .) + install(FILES ${PROJECT_BINARY_DIR}/config-log.toml.sample DESTINATION .) if(WIN32) set(PLATFORM_QT_PACKAGES WinExtras) else() diff --git a/nano/nano_node/CMakeLists.txt b/nano/nano_node/CMakeLists.txt index 5da26671ee..48d42d3586 100644 --- a/nano/nano_node/CMakeLists.txt +++ b/nano/nano_node/CMakeLists.txt @@ -18,7 +18,9 @@ add_custom_command( COMMAND nano_node --generate_config node > ${PROJECT_BINARY_DIR}/config-node.toml.sample COMMAND nano_node --generate_config rpc > - ${PROJECT_BINARY_DIR}/config-rpc.toml.sample) + ${PROJECT_BINARY_DIR}/config-rpc.toml.sample + COMMAND nano_node --generate_config log > + ${PROJECT_BINARY_DIR}/config-log.toml.sample) if((NANO_GUI OR RAIBLOCKS_GUI) AND NOT APPLE) if(WIN32) diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 9ec0539b4c..2636f5a144 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -58,7 +58,7 @@ void nano::add_node_options (boost::program_options::options_description & descr ("rebuild_database", "Rebuild LMDB database with vacuum for best compaction") ("migrate_database_lmdb_to_rocksdb", "Migrates LMDB database to RocksDB") ("diagnostics", "Run internal diagnostics") - ("generate_config", boost::program_options::value (), "Write configuration to stdout, populated with defaults suitable for this system. Pass the configuration type node, rpc or tls. See also use_defaults.") + ("generate_config", boost::program_options::value (), "Write configuration to stdout, populated with defaults suitable for this system. Pass the configuration type node, rpc or log. See also use_defaults.") ("key_create", "Generates a adhoc random keypair and prints it to stdout") ("key_expand", "Derive public key and account number from ") ("wallet_add_adhoc", "Insert in to ") @@ -671,6 +671,12 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map nano::rpc_config config{ nano::dev::network_params.network }; config.serialize_toml (toml); } + else if (type == "log") + { + valid_type = true; + nano::log_config config{ nano::log_config::daemon_default () }; + config.serialize_toml (toml); + } else if (type == "tls") { valid_type = true; From 035c365edb55659987e503967d1f9c03056a4f31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 17 Jan 2024 00:00:01 +0100 Subject: [PATCH 010/190] Load node id during node initialization --- nano/core_test/node.cpp | 8 ++++---- nano/lib/logging_enums.hpp | 1 + nano/nano_node/daemon.cpp | 2 ++ nano/nano_node/daemon.hpp | 2 +- nano/node/node.cpp | 19 ++++++++++++------- nano/node/node.hpp | 6 ++++-- 6 files changed, 24 insertions(+), 14 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 69eae14b0e..d7fe9762bd 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -4314,19 +4314,19 @@ TEST (node_config, node_id_private_key_persistence) auto priv_key_filename = path / "node_id_private.key"; // check that the key generated is random when the key does not exist - nano::keypair kp1 = nano::load_or_create_node_id (path, system.nlogger); + nano::keypair kp1 = nano::load_or_create_node_id (path); std::filesystem::remove (priv_key_filename); - nano::keypair kp2 = nano::load_or_create_node_id (path, system.nlogger); + nano::keypair kp2 = nano::load_or_create_node_id (path); ASSERT_NE (kp1.prv, kp2.prv); // check that the key persists - nano::keypair kp3 = nano::load_or_create_node_id (path, system.nlogger); + nano::keypair kp3 = nano::load_or_create_node_id (path); ASSERT_EQ (kp2.prv, kp3.prv); // write the key file manually and check that right key is loaded std::ofstream ofs (priv_key_filename.string (), std::ofstream::out | std::ofstream::trunc); ofs << "3F28D035B8AA75EA53DF753BFD065CF6138E742971B2C99B84FD8FE328FED2D9" << std::flush; ofs.close (); - nano::keypair kp4 = nano::load_or_create_node_id (path, system.nlogger); + nano::keypair kp4 = nano::load_or_create_node_id (path); ASSERT_EQ (kp4.prv, nano::keypair ("3F28D035B8AA75EA53DF753BFD065CF6138E742971B2C99B84FD8FE328FED2D9").prv); } diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index 64969fd34e..be52eaf6cc 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -22,6 +22,7 @@ enum class type all = 0, // reserved generic, + init, config, logging, node, diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 08b5108384..4f2f8dffe1 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -77,7 +77,9 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag nano::network_params network_params{ nano::network_constants::active_network }; nano::daemon_config config{ data_path, network_params }; auto error = nano::read_node_config_toml (data_path, config, flags.config_overrides); + nano::set_use_memory_pools (config.node.use_memory_pools); + if (!error) { error = nano::flags_config_conflicts (flags, config.node); diff --git a/nano/nano_node/daemon.hpp b/nano/nano_node/daemon.hpp index 3b4c232e77..b3d365ce39 100644 --- a/nano/nano_node/daemon.hpp +++ b/nano/nano_node/daemon.hpp @@ -6,7 +6,7 @@ class node_flags; class daemon { - nano::nlogger nlogger; + nano::nlogger nlogger{ "daemon" }; public: void run (std::filesystem::path const &, nano::node_flags const & flags); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index f6cb17ebd1..07c6922c6c 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -103,13 +103,13 @@ std::unique_ptr nano::collect_container_info (re return composite; } -nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path, nano::nlogger & nlogger) +nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path) { auto node_private_key_path = application_path / "node_id_private.key"; std::ifstream ifs (node_private_key_path.c_str ()); if (ifs.good ()) { - nlogger.debug (nano::log::type::node, "Reading node id from: '{}'", node_private_key_path.string ()); + nano::default_logger ().info (nano::log::type::init, "Reading node id from: '{}'", node_private_key_path.string ()); std::string node_private_key; ifs >> node_private_key; @@ -120,7 +120,7 @@ nano::keypair nano::load_or_create_node_id (std::filesystem::path const & applic else { // no node_id found, generate new one - nlogger.debug (nano::log::type::node, "Generating a new node id, saving to: '{}'", node_private_key_path.string ()); + nano::default_logger ().info (nano::log::type::init, "Generating a new node id, saving to: '{}'", node_private_key_path.string ()); nano::keypair kp; std::ofstream ofs (node_private_key_path.c_str (), std::ofstream::out | std::ofstream::trunc); @@ -138,12 +138,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, s } nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path const & application_path_a, nano::node_config const & config_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) : + node_id{ load_or_create_node_id (application_path_a) }, write_database_queue (!flags_a.force_use_write_database_queue && (config_a.rocksdb_config.enable)), io_ctx (io_ctx_a), node_initialized_latch (1), config (config_a), network_params{ config.network_params }, - nlogger{ "node" }, + nlogger{ make_logger_identifier (node_id) }, stats (config.stats_config), workers{ config.background_threads, nano::thread_role::name::worker }, bootstrap_workers{ config.bootstrap_serving_threads, nano::thread_role::name::bootstrap_worker }, @@ -348,6 +349,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons nlogger.info (nano::log::type::node, "Data path: {}", application_path.string ()); nlogger.info (nano::log::type::node, "Work pool threads: {} ({})", work.threads.size (), (work.opencl ? "OpenCL" : "CPU")); nlogger.info (nano::log::type::node, "Work peers: {}", config.work_peers.size ()); + nlogger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ()); if (!work_generation_enabled ()) { @@ -398,9 +400,6 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons } } - node_id = nano::load_or_create_node_id (application_path, nlogger); - nlogger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ()); - if ((network_params.network.is_live_network () || network_params.network.is_beta_network ()) && !flags.inactive_node) { auto const bootstrap_weights = get_bootstrap_weights (); @@ -1476,6 +1475,12 @@ nano::telemetry_data nano::node::local_telemetry () const return telemetry_data; } +std::string nano::node::make_logger_identifier (const nano::keypair & node_id) +{ + // Node identifier consists of first 10 characters of node id + return node_id.pub.to_node_id ().substr (0, 10); +} + /* * node_wrapper */ diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 3e1324bd9a..f0408d6cc8 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -140,6 +140,7 @@ class node final : public std::enable_shared_from_this nano::telemetry_data local_telemetry () const; public: + const nano::keypair node_id; nano::write_database_queue write_database_queue; boost::asio::io_context & io_ctx; boost::latch node_initialized_latch; @@ -175,7 +176,6 @@ class node final : public std::enable_shared_from_this nano::block_processor block_processor; nano::block_arrival block_arrival; nano::local_vote_history history; - nano::keypair node_id; nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer; nano::confirmation_height_processor confirmation_height_processor; @@ -227,9 +227,11 @@ class node final : public std::enable_shared_from_this private: void long_inactivity_cleanup (); + + static std::string make_logger_identifier (nano::keypair const & node_id); }; -nano::keypair load_or_create_node_id (std::filesystem::path const & application_path, nano::nlogger &); +nano::keypair load_or_create_node_id (std::filesystem::path const & application_path); std::unique_ptr collect_container_info (node & node, std::string const & name); From cbda8588cd5ad3431d2a0f85f032a9245da08b75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 17 Jan 2024 16:10:08 +0100 Subject: [PATCH 011/190] Special log formatter for running tests --- nano/core_test/core_test_main.cc | 2 +- nano/lib/logging.cpp | 116 +++++++++++++++++++++++++++---- nano/lib/logging.hpp | 5 ++ nano/load_test/entry.cpp | 2 +- nano/qt_test/entry.cpp | 2 +- nano/rpc_test/entry.cpp | 2 +- nano/slow_test/entry.cpp | 2 +- 7 files changed, 113 insertions(+), 18 deletions(-) diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index c2f2d22136..51e8e81669 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -19,7 +19,7 @@ void force_nano_dev_network (); GTEST_API_ int main (int argc, char ** argv) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index aafc146624..68c2ccc27a 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include @@ -24,12 +25,102 @@ nano::nlogger & nano::default_logger () * nlogger */ -bool nano::nlogger::global_initialized; -nano::log_config nano::nlogger::global_config; -std::vector nano::nlogger::global_sinks; +bool nano::nlogger::global_initialized{ false }; +nano::log_config nano::nlogger::global_config{}; +std::vector nano::nlogger::global_sinks{}; + +// By default, use only the tag as the logger name, since only one node is running in the process +std::function nano::nlogger::global_name_formatter{ [] (auto tag, auto identifier) { + return std::string{ to_string (tag) }; +} }; void nano::nlogger::initialize (nano::log_config config) { + initialize_common (config); + + global_initialized = true; +} + +// Custom log formatter flags +namespace +{ +/// Takes a qualified identifier in the form `node_identifier::tag` and splits it into a pair of `identifier` and `tag` +/// It is a limitation of spldlog that we cannot attach additional data to the logger, so we have to encode the node identifier in the logger name +/// @returns +std::pair split_qualified_identifier (std::string_view qualified_identifier) +{ + auto pos = qualified_identifier.find ("::"); + debug_assert (pos != std::string_view::npos); // This should never happen, since the default logger name formatter always adds the tag + if (pos == std::string_view::npos) + { + return { std::string_view{}, qualified_identifier }; + } + else + { + return { qualified_identifier.substr (0, pos), qualified_identifier.substr (pos + 2) }; + } +} + +class identifier_formatter_flag : public spdlog::custom_flag_formatter +{ +public: + void format (const spdlog::details::log_msg & msg, const std::tm & tm, spdlog::memory_buf_t & dest) override + { + // Extract identifier and tag from logger name + auto [identifier, tag] = split_qualified_identifier (std::string_view (msg.logger_name.data (), msg.logger_name.size ())); + dest.append (identifier.data (), identifier.data () + identifier.size ()); + } + + std::unique_ptr clone () const override + { + return spdlog::details::make_unique (); + } +}; + +class tag_formatter_flag : public spdlog::custom_flag_formatter +{ +public: + void format (const spdlog::details::log_msg & msg, const std::tm & tm, spdlog::memory_buf_t & dest) override + { + // Extract identifier and tag from logger name + auto [identifier, tag] = split_qualified_identifier (std::string_view (msg.logger_name.data (), msg.logger_name.size ())); + dest.append (tag.data (), tag.data () + tag.size ()); + } + + std::unique_ptr clone () const override + { + return spdlog::details::make_unique (); + } +}; +} + +void nano::nlogger::initialize_for_tests (nano::log_config config) +{ + initialize_common (config); + + // Use tag and identifier as the logger name, since multiple nodes may be running in the same process + global_name_formatter = [] (nano::log::type tag, std::string identifier) { + return fmt::format ("{}::{}", identifier, to_string (tag)); + }; + + auto formatter = std::make_unique (); + formatter->add_flag ('i'); + formatter->add_flag ('n'); + formatter->set_pattern ("[%Y-%m-%d %H:%M:%S.%e] [%i] [%n] [%l] %v"); + + for (auto & sink : global_sinks) + { + // Make deep copy of formatter for each sink + sink->set_formatter (formatter->clone ()); + } + + global_initialized = true; +} + +void nano::nlogger::initialize_common (nano::log_config const & config) +{ + global_config = config; + spdlog::set_automatic_registration (false); spdlog::set_level (to_spdlog_level (config.default_level)); spdlog::cfg::load_env_levels (); @@ -72,7 +163,7 @@ void nano::nlogger::initialize (nano::log_config config) std::filesystem::path log_path{ "log" }; log_path /= filename + ".log"; - nano::default_logger ().info (nano::log::type::logging, "Logging to file: {}", log_path.string ()); + std::cerr << "Logging to file: " << log_path.string () << std::endl; // If either max_size or rotation_count is 0, then disable file rotation if (config.file.max_size == 0 || config.file.rotation_count == 0) @@ -88,11 +179,6 @@ void nano::nlogger::initialize (nano::log_config config) global_sinks.push_back (file_sink); } } - - auto logger = std::make_shared ("default", global_sinks.begin (), global_sinks.end ()); - spdlog::set_default_logger (logger); - - global_initialized = true; } void nano::nlogger::flush () @@ -134,19 +220,23 @@ spdlog::logger & nano::nlogger::get_logger (nano::log::type tag) std::shared_ptr nano::nlogger::make_logger (nano::log::type tag) { - auto spd_logger = std::make_shared (std::string{ to_string (tag) }, global_sinks.begin (), global_sinks.end ()); + auto const & config = global_config; + auto const & sinks = global_sinks; - spdlog::initialize_logger (spd_logger); + auto name = global_name_formatter (tag, identifier); + auto spd_logger = std::make_shared (name, sinks.begin (), sinks.end ()); - if (auto it = global_config.levels.find ({ tag, nano::log::detail::all }); it != global_config.levels.end ()) + if (auto it = config.levels.find ({ tag, nano::log::detail::all }); it != config.levels.end ()) { spd_logger->set_level (to_spdlog_level (it->second)); } else { - spd_logger->set_level (to_spdlog_level (global_config.default_level)); + spd_logger->set_level (to_spdlog_level (config.default_level)); } + spd_logger->flush_on (to_spdlog_level (config.flush_level)); + return spd_logger; } diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 26df820ff6..a9b10c6693 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -24,6 +24,7 @@ class log_config final public: nano::log::level default_level{ nano::log::level::info }; + nano::log::level flush_level{ nano::log::level::error }; using logger_id_t = std::pair; std::map levels{ default_levels (default_level) }; @@ -75,12 +76,16 @@ class nlogger final public: static void initialize (nano::log_config); + static void initialize_for_tests (nano::log_config); static void flush (); private: static bool global_initialized; static nano::log_config global_config; static std::vector global_sinks; + static std::function global_name_formatter; + + static void initialize_common (nano::log_config const &); public: template diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index ea26bee3c6..3fe7134648 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -491,7 +491,7 @@ account_info account_info_rpc (boost::asio::io_context & ioc, tcp::resolver::res /** This launches a node and fires a lot of send/recieve RPC requests at it (configurable), then other nodes are tested to make sure they observe these blocks as well. */ int main (int argc, char * const * argv) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); boost::program_options::options_description description ("Command line options"); diff --git a/nano/qt_test/entry.cpp b/nano/qt_test/entry.cpp index 6208cbb229..3ac2f817f1 100644 --- a/nano/qt_test/entry.cpp +++ b/nano/qt_test/entry.cpp @@ -17,7 +17,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; QApplication application (argc, argv); diff --git a/nano/rpc_test/entry.cpp b/nano/rpc_test/entry.cpp index 3f81484360..06b87f9370 100644 --- a/nano/rpc_test/entry.cpp +++ b/nano/rpc_test/entry.cpp @@ -15,7 +15,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::set_use_memory_pools (false); nano::node_singleton_memory_pool_purge_guard cleanup_guard; diff --git a/nano/slow_test/entry.cpp b/nano/slow_test/entry.cpp index d7cf3c6846..cec8cabce2 100644 --- a/nano/slow_test/entry.cpp +++ b/nano/slow_test/entry.cpp @@ -14,7 +14,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; testing::InitGoogleTest (&argc, argv); From 61ff7f4c7a58e8881f633109ab6523433ee60421 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 17 Jan 2024 16:22:21 +0100 Subject: [PATCH 012/190] Fix unique directories usage in tests --- nano/core_test/block_store.cpp | 1 + nano/core_test/node.cpp | 2 +- nano/core_test/wallet.cpp | 38 +++++++++++++++++----------------- nano/secure/utility.cpp | 12 +++-------- nano/store/lmdb/lmdb_env.cpp | 2 ++ 5 files changed, 26 insertions(+), 29 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 48808e2f31..fa2bd3286b 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -675,6 +675,7 @@ TEST (mdb_block_store, bad_path) try { auto path = nano::unique_path (); + path /= "data.ldb"; { std::ofstream stream (path.c_str ()); } diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index d7fe9762bd..c6f8861c1d 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -4310,7 +4310,7 @@ TEST (node_config, node_id_private_key_persistence) // create the directory and the file auto path = nano::unique_path (); - ASSERT_TRUE (std::filesystem::create_directories (path)); + ASSERT_TRUE (std::filesystem::exists (path)); auto priv_key_filename = path / "node_id_private.key"; // check that the key generated is random when the key does not exist diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index b750538b12..c27749522f 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -12,7 +12,7 @@ unsigned constexpr nano::wallet_store::version_current; TEST (wallet, no_special_keys_accounts) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -33,7 +33,7 @@ TEST (wallet, no_special_keys_accounts) TEST (wallet, no_key) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -48,7 +48,7 @@ TEST (wallet, no_key) TEST (wallet, fetch_locked) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -70,7 +70,7 @@ TEST (wallet, fetch_locked) TEST (wallet, retrieval) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -92,7 +92,7 @@ TEST (wallet, retrieval) TEST (wallet, empty_iteration) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -106,7 +106,7 @@ TEST (wallet, empty_iteration) TEST (wallet, one_item_iteration) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -128,7 +128,7 @@ TEST (wallet, one_item_iteration) TEST (wallet, two_item_iteration) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); nano::keypair key1; nano::keypair key2; @@ -267,7 +267,7 @@ TEST (wallet, spend_no_previous) TEST (wallet, find_none) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -280,7 +280,7 @@ TEST (wallet, find_none) TEST (wallet, find_existing) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -299,7 +299,7 @@ TEST (wallet, find_existing) TEST (wallet, rekey) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -371,7 +371,7 @@ TEST (account, encode_fail) TEST (wallet, hash_password) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -420,7 +420,7 @@ TEST (fan, change) TEST (wallet, reopen_default_password) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); auto transaction (env.tx_begin_write ()); ASSERT_FALSE (init); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -456,7 +456,7 @@ TEST (wallet, reopen_default_password) TEST (wallet, representative) { auto error (false); - nano::store::lmdb::env env (error, nano::unique_path ()); + nano::store::lmdb::env env (error, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -477,7 +477,7 @@ TEST (wallet, representative) TEST (wallet, serialize_json_empty) { auto error (false); - nano::store::lmdb::env env (error, nano::unique_path ()); + nano::store::lmdb::env env (error, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -502,7 +502,7 @@ TEST (wallet, serialize_json_empty) TEST (wallet, serialize_json_one) { auto error (false); - nano::store::lmdb::env env (error, nano::unique_path ()); + nano::store::lmdb::env env (error, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -531,7 +531,7 @@ TEST (wallet, serialize_json_one) TEST (wallet, serialize_json_password) { auto error (false); - nano::store::lmdb::env env (error, nano::unique_path ()); + nano::store::lmdb::env env (error, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -564,7 +564,7 @@ TEST (wallet, serialize_json_password) TEST (wallet_store, move) { auto error (false); - nano::store::lmdb::env env (error, nano::unique_path ()); + nano::store::lmdb::env env (error, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -722,7 +722,7 @@ TEST (wallet, insert_locked) TEST (wallet, deterministic_keys) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; @@ -765,7 +765,7 @@ TEST (wallet, deterministic_keys) TEST (wallet, reseed) { bool init; - nano::store::lmdb::env env (init, nano::unique_path ()); + nano::store::lmdb::env env (init, nano::unique_path () / "wallet.ldb"); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp index 19c5836294..0ed99eb9b1 100644 --- a/nano/secure/utility.cpp +++ b/nano/secure/utility.cpp @@ -46,6 +46,9 @@ std::filesystem::path nano::unique_path (nano::networks network) } auto result = working_path (network) / random_string; + + std::filesystem::create_directories (result); + all_unique_paths.push_back (result); return result; } @@ -60,15 +63,6 @@ void nano::remove_temporary_directories () { std::cerr << "Could not remove temporary directory: " << ec.message () << std::endl; } - - // lmdb creates a -lock suffixed file for its MDB_NOSUBDIR databases - auto lockfile = path; - lockfile += "-lock"; - std::filesystem::remove (lockfile, ec); - if (ec) - { - std::cerr << "Could not remove temporary lock file: " << ec.message () << std::endl; - } } } diff --git a/nano/store/lmdb/lmdb_env.cpp b/nano/store/lmdb/lmdb_env.cpp index 9e627c7676..e66511da4c 100644 --- a/nano/store/lmdb/lmdb_env.cpp +++ b/nano/store/lmdb/lmdb_env.cpp @@ -8,6 +8,8 @@ nano::store::lmdb::env::env (bool & error_a, std::filesystem::path const & path_ void nano::store::lmdb::env::init (bool & error_a, std::filesystem::path const & path_a, nano::store::lmdb::env::options options_a) { + debug_assert (path_a.extension () == ".ldb", "invalid filename extension for lmdb database file"); + boost::system::error_code error_mkdir, error_chmod; if (path_a.has_parent_path ()) { From de28085281962e2bd172a5c12f3488c2394ed18d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 18 Jan 2024 00:19:37 +0100 Subject: [PATCH 013/190] Load log levels from environment variables --- nano/lib/logging.cpp | 82 ++++++++++++++++++++++++++++++++++---- nano/lib/logging.hpp | 7 ++-- nano/lib/logging_enums.cpp | 6 +-- nano/lib/logging_enums.hpp | 6 +-- nano/lib/utility.hpp | 12 ++++++ nano/node/cli.cpp | 2 +- 6 files changed, 97 insertions(+), 18 deletions(-) diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 68c2ccc27a..342f402e35 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -269,22 +269,32 @@ spdlog::level::level_enum nano::to_spdlog_level (nano::log::level level) nano::log_config nano::log_config::cli_default () { - log_config config; + log_config config{}; config.default_level = nano::log::level::critical; + config.console.to_cerr = true; // Use cerr to avoid interference with CLI output that goes to stdout + config.file.enable = false; return config; } nano::log_config nano::log_config::daemon_default () { - log_config config; + log_config config{}; config.default_level = nano::log::level::info; return config; } nano::log_config nano::log_config::tests_default () { - log_config config; - config.default_level = nano::log::level::critical; + log_config config{}; + config.default_level = nano::log::level::off; + return config; +} + +nano::log_config nano::log_config::sample_config () +{ + log_config config{}; + config.default_level = nano::log::level::info; + config.levels = default_levels (nano::log::level::info); // Populate with default levels return config; } @@ -349,7 +359,7 @@ void nano::log_config::deserialize (nano::tomlconfig & toml) if (toml.has_key ("default_level")) { auto default_level_l = toml.get ("default_level"); - default_level = nano::log::to_level (default_level_l); + default_level = nano::log::parse_level (default_level_l); } if (toml.has_key ("console")) @@ -376,7 +386,7 @@ void nano::log_config::deserialize (nano::tomlconfig & toml) try { auto & [name_str, level_str] = level; - auto logger_level = nano::log::to_level (level_str); + auto logger_level = nano::log::parse_level (level_str); auto logger_id = parse_logger_id (name_str); levels[logger_id] = logger_level; @@ -399,14 +409,14 @@ nano::log_config::logger_id_t nano::log_config::parse_logger_id (const std::stri auto pos = logger_name.find ("::"); if (pos == std::string::npos) { - return { nano::log::to_type (logger_name), nano::log::detail::all }; + return { nano::log::parse_type (logger_name), nano::log::detail::all }; } else { auto logger_type = logger_name.substr (0, pos); auto logger_detail = logger_name.substr (pos + 1); - return { nano::log::to_type (logger_type), nano::log::to_detail (logger_detail) }; + return { nano::log::parse_type (logger_type), nano::log::parse_detail (logger_detail) }; } } @@ -430,6 +440,62 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi try { auto config = nano::load_config_file (fallback, config_filename, data_path, config_overrides); + + // Parse default log level from environment variable, e.g. "NANO_LOG=debug" + auto env_level = nano::get_env ("NANO_LOG"); + if (env_level) + { + try + { + config.default_level = nano::log::parse_level (*env_level); + + std::cerr << "Using default log level from NANO_LOG environment variable: " << *env_level << std::endl; + } + catch (std::invalid_argument const & ex) + { + std::cerr << "Invalid log level from NANO_LOG environment variable: " << ex.what () << std::endl; + } + } + + // Parse per logger levels from environment variable, e.g. "NANO_LOG_LEVELS=ledger=debug,node=trace" + auto env_levels = nano::get_env ("NANO_LOG_LEVELS"); + if (env_levels) + { + std::map levels; + for (auto const & env_level_str : nano::util::split (*env_levels, ',')) + { + try + { + // Split 'logger_name=level' into a pair of 'logger_name' and 'level' + auto arr = nano::util::split (env_level_str, '='); + if (arr.size () != 2) + { + throw std::invalid_argument ("Invalid entry: " + env_level_str); + } + + auto name_str = arr[0]; + auto level_str = arr[1]; + + auto logger_id = nano::log_config::parse_logger_id (name_str); + auto logger_level = nano::log::parse_level (level_str); + + levels[logger_id] = logger_level; + + std::cerr << "Using logger log level from NANO_LOG_LEVELS environment variable: " << name_str << "=" << level_str << std::endl; + } + catch (std::invalid_argument const & ex) + { + std::cerr << "Invalid log level from NANO_LOG_LEVELS environment variable: " << ex.what () << std::endl; + } + } + + // Merge with existing levels + for (auto const & [logger_id, level] : levels) + { + config.levels[logger_id] = level; + } + } + return config; } catch (std::runtime_error const & ex) diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index a9b10c6693..9906b45f28 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -27,7 +27,7 @@ class log_config final nano::log::level flush_level{ nano::log::level::error }; using logger_id_t = std::pair; - std::map levels{ default_levels (default_level) }; + std::map levels; struct console_config { @@ -50,10 +50,11 @@ class log_config final static log_config cli_default (); static log_config daemon_default (); static log_config tests_default (); + static log_config sample_config (); // For auto-generated sample config files -private: - logger_id_t parse_logger_id (std::string const &); + static logger_id_t parse_logger_id (std::string const &); +private: /// Returns placeholder log levels for all loggers static std::map default_levels (nano::log::level); }; diff --git a/nano/lib/logging_enums.cpp b/nano/lib/logging_enums.cpp index a82996aa70..b1a55f4485 100644 --- a/nano/lib/logging_enums.cpp +++ b/nano/lib/logging_enums.cpp @@ -47,7 +47,7 @@ const std::vector & nano::log::all_types () return all; } -nano::log::level nano::log::to_level (std::string_view name) +nano::log::level nano::log::parse_level (std::string_view name) { auto value = magic_enum::enum_cast (name); if (value.has_value ()) @@ -64,7 +64,7 @@ nano::log::level nano::log::to_level (std::string_view name) } } -nano::log::type nano::log::to_type (std::string_view name) +nano::log::type nano::log::parse_type (std::string_view name) { auto value = magic_enum::enum_cast (name); if (value.has_value ()) @@ -77,7 +77,7 @@ nano::log::type nano::log::to_type (std::string_view name) } } -nano::log::detail nano::log::to_detail (std::string_view name) +nano::log::detail nano::log::parse_detail (std::string_view name) { auto value = magic_enum::enum_cast (name); if (value.has_value ()) diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index be52eaf6cc..a0e5306256 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -129,13 +129,13 @@ std::string_view to_string (nano::log::detail); std::string_view to_string (nano::log::level); /// @throw std::invalid_argument if the input string does not match a log::level -nano::log::level to_level (std::string_view); +nano::log::level parse_level (std::string_view); /// @throw std::invalid_argument if the input string does not match a log::type -nano::log::type to_type (std::string_view); +nano::log::type parse_type (std::string_view); /// @throw std::invalid_argument if the input string does not match a log::detail -nano::log::detail to_detail (std::string_view); +nano::log::detail parse_detail (std::string_view); std::vector const & all_levels (); std::vector const & all_types (); diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 5ec06f6e9e..331c0534ab 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -245,6 +245,18 @@ std::string join (Container const & container, std::string_view delimiter, Func return join (container.begin (), container.end (), delimiter, transform); } +inline std::vector split (const std::string & str, char delimiter) +{ + std::stringstream ss{ str }; + std::vector result; + std::string item; + while (std::getline (ss, item, delimiter)) + { + result.push_back (item); + } + return result; +} + template std::string to_str (T const & val) { diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 2636f5a144..26fe004923 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -674,7 +674,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map else if (type == "log") { valid_type = true; - nano::log_config config{ nano::log_config::daemon_default () }; + nano::log_config config = nano::log_config::sample_config (); config.serialize_toml (toml); } else if (type == "tls") From 8e7542052def50653bd72a3af669ab6b954630ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 18 Jan 2024 14:34:49 +0100 Subject: [PATCH 014/190] Store log files in node data path --- nano/core_test/core_test_main.cc | 2 +- nano/lib/config.cpp | 51 +++++++++++++------------------- nano/lib/logging.cpp | 25 +++++++++------- nano/lib/logging.hpp | 6 ++-- nano/load_test/entry.cpp | 2 +- nano/nano_node/daemon.cpp | 2 +- nano/nano_wallet/entry.cpp | 2 +- nano/qt_test/entry.cpp | 2 +- nano/rpc_test/entry.cpp | 2 +- nano/slow_test/entry.cpp | 2 +- 10 files changed, 44 insertions(+), 52 deletions(-) diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index 51e8e81669..f165199a83 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -19,7 +19,7 @@ void force_nano_dev_network (); GTEST_API_ int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index f722b0e66a..d8b3a60d74 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -386,40 +386,29 @@ nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_file } config_overrides_stream << std::endl; - auto try_load_toml = [&config_overrides_stream] (auto toml_config_path) -> std::optional { - // Make sure we don't create an empty toml file if it doesn't exist. Running without a toml file is the default. - if (std::filesystem::exists (toml_config_path)) + // Make sure we don't create an empty toml file if it doesn't exist. Running without a toml file is the default. + auto toml_config_path = data_path / config_filename; + if (std::filesystem::exists (toml_config_path)) + { + nano::tomlconfig toml; + auto error = toml.read (config_overrides_stream, toml_config_path); + if (error) { - nano::tomlconfig toml; - auto error = toml.read (config_overrides_stream, toml_config_path); - if (error) - { - throw std::runtime_error (error.get_message ()); - } - return toml; + throw std::runtime_error (error.get_message ()); } - return std::nullopt; - }; - - // First try to load config from the current working directory, then from the node data directory - if (auto toml = try_load_toml (config_filename); toml) - { - nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from current working directory", config_filename.string ()); - return *toml; - } - if (auto toml = try_load_toml (data_path / config_filename); toml) - { - nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from node data directory ({})", config_filename.string (), data_path.string ()); - return *toml; + nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from node data directory: ", config_filename.string (), toml_config_path.string ()); + return toml; } - - // If no config was found, return an empty config with overrides applied - nano::tomlconfig toml; - auto error = toml.read (config_overrides_stream); - if (error) + else { - throw std::runtime_error (error.get_message ()); + // If no config was found, return an empty config with overrides applied + nano::tomlconfig toml; + auto error = toml.read (config_overrides_stream); + if (error) + { + throw std::runtime_error (error.get_message ()); + } + nano::default_logger ().info (nano::log::type::config, "Config for `{}` not found, using default configuration", config_filename.string ()); + return toml; } - nano::default_logger ().info (nano::log::type::config, "Config for `{}` not found, using default configuration", config_filename.string ()); - return toml; } diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 342f402e35..8f491850b0 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -34,10 +34,10 @@ std::function nano::n return std::string{ to_string (tag) }; } }; -void nano::nlogger::initialize (nano::log_config config) +void nano::nlogger::initialize (nano::log_config fallback, std::filesystem::path data_path, std::vector const & config_overrides) { - initialize_common (config); - + auto config = nano::load_log_config (std::move (fallback), data_path, config_overrides); + initialize_common (config, data_path); global_initialized = true; } @@ -47,6 +47,7 @@ namespace /// Takes a qualified identifier in the form `node_identifier::tag` and splits it into a pair of `identifier` and `tag` /// It is a limitation of spldlog that we cannot attach additional data to the logger, so we have to encode the node identifier in the logger name /// @returns + std::pair split_qualified_identifier (std::string_view qualified_identifier) { auto pos = qualified_identifier.find ("::"); @@ -94,15 +95,17 @@ class tag_formatter_flag : public spdlog::custom_flag_formatter }; } -void nano::nlogger::initialize_for_tests (nano::log_config config) +void nano::nlogger::initialize_for_tests (nano::log_config fallback) { - initialize_common (config); + auto config = nano::load_log_config (std::move (fallback), /* load log config from current workdir */ {}); + initialize_common (config, /* store log file in current workdir */ {}); // Use tag and identifier as the logger name, since multiple nodes may be running in the same process global_name_formatter = [] (nano::log::type tag, std::string identifier) { return fmt::format ("{}::{}", identifier, to_string (tag)); }; + // Setup formatter to include information about node identifier `[%i]` and tag `[%n]` auto formatter = std::make_unique (); formatter->add_flag ('i'); formatter->add_flag ('n'); @@ -110,14 +113,13 @@ void nano::nlogger::initialize_for_tests (nano::log_config config) for (auto & sink : global_sinks) { - // Make deep copy of formatter for each sink sink->set_formatter (formatter->clone ()); } global_initialized = true; } -void nano::nlogger::initialize_common (nano::log_config const & config) +void nano::nlogger::initialize_common (nano::log_config const & config, std::filesystem::path data_path) { global_config = config; @@ -160,8 +162,8 @@ void nano::nlogger::initialize_common (nano::log_config const & config) auto filename = fmt::format ("log_{:%Y-%m-%d_%H-%M}-{:%S}", fmt::localtime (time), now.time_since_epoch ()); std::replace (filename.begin (), filename.end (), '.', '_'); // Replace millisecond dot separator with underscore - std::filesystem::path log_path{ "log" }; - log_path /= filename + ".log"; + std::filesystem::path log_path{ data_path / "log" / (filename + ".log") }; + log_path = std::filesystem::absolute (log_path); std::cerr << "Logging to file: " << log_path.string () << std::endl; @@ -170,12 +172,12 @@ void nano::nlogger::initialize_common (nano::log_config const & config) { // TODO: Maybe show a warning to the user about possibly unlimited log file size - auto file_sink = std::make_shared (log_path, true); + auto file_sink = std::make_shared (log_path.string (), true); global_sinks.push_back (file_sink); } else { - auto file_sink = std::make_shared (log_path, config.file.max_size, config.file.rotation_count); + auto file_sink = std::make_shared (log_path.string (), config.file.max_size, config.file.rotation_count); global_sinks.push_back (file_sink); } } @@ -287,6 +289,7 @@ nano::log_config nano::log_config::tests_default () { log_config config{}; config.default_level = nano::log::level::off; + config.file.enable = false; return config; } diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 9906b45f28..1c23d49ba2 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -76,8 +76,8 @@ class nlogger final nlogger (nlogger const &) = delete; public: - static void initialize (nano::log_config); - static void initialize_for_tests (nano::log_config); + static void initialize (nano::log_config fallback, std::filesystem::path data_path = {}, std::vector const & config_overrides = std::vector ()); + static void initialize_for_tests (nano::log_config fallback); static void flush (); private: @@ -86,7 +86,7 @@ class nlogger final static std::vector global_sinks; static std::function global_name_formatter; - static void initialize_common (nano::log_config const &); + static void initialize_common (nano::log_config const &, std::filesystem::path data_path); public: template diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index 3fe7134648..a159d05cd8 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -491,7 +491,7 @@ account_info account_info_rpc (boost::asio::io_context & ioc, tcp::resolver::res /** This launches a node and fires a lot of send/recieve RPC requests at it (configurable), then other nodes are tested to make sure they observe these blocks as well. */ int main (int argc, char * const * argv) { - nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); boost::program_options::options_description description ("Command line options"); diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 4f2f8dffe1..728cd5ad0d 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -63,7 +63,7 @@ constexpr std::size_t OPEN_FILE_DESCRIPTORS_LIMIT = 16384; void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flags const & flags) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::daemon_default (), data_path, flags.config_overrides)); + nano::nlogger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); nlogger.info (nano::log::type::daemon, "Daemon started"); diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 04e55e14d2..3c863c06f1 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -74,7 +74,7 @@ nano::error read_wallet_config (nano::wallet_config & config_a, std::filesystem: int run_wallet (QApplication & application, int argc, char * const * argv, std::filesystem::path const & data_path, nano::node_flags const & flags) { - nano::nlogger::initialize (nano::load_log_config (nano::log_config::daemon_default (), data_path, flags.config_overrides)); + nano::nlogger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); nlogger.info (nano::log::type::daemon_wallet, "Daemon started (wallet)"); diff --git a/nano/qt_test/entry.cpp b/nano/qt_test/entry.cpp index 3ac2f817f1..a34cb347dd 100644 --- a/nano/qt_test/entry.cpp +++ b/nano/qt_test/entry.cpp @@ -17,7 +17,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; QApplication application (argc, argv); diff --git a/nano/rpc_test/entry.cpp b/nano/rpc_test/entry.cpp index 06b87f9370..be70e1183e 100644 --- a/nano/rpc_test/entry.cpp +++ b/nano/rpc_test/entry.cpp @@ -15,7 +15,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::set_use_memory_pools (false); nano::node_singleton_memory_pool_purge_guard cleanup_guard; diff --git a/nano/slow_test/entry.cpp b/nano/slow_test/entry.cpp index cec8cabce2..5e3ff3ea5a 100644 --- a/nano/slow_test/entry.cpp +++ b/nano/slow_test/entry.cpp @@ -14,7 +14,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::load_log_config (nano::log_config::tests_default ())); + nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; testing::InitGoogleTest (&argc, argv); From d01547859988294ee4cc07bf8b8d98342a78176e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 19 Jan 2024 13:48:24 +0100 Subject: [PATCH 015/190] Fix setting socket local endpoint --- nano/node/transport/tcp_server.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 3b920c1c34..83dfef4924 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -171,6 +171,12 @@ void nano::transport::tcp_listener::on_connection (std::functionlocal = new_connection->tcp_socket.local_endpoint (ec); + } + // Make sure the new connection doesn't idle. Note that in most cases, the callback is going to start // an IO operation immediately, which will start a timer. new_connection->start (); From c14ed4cc1948172e36cd80368f7ca4198cd189f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 19 Jan 2024 13:54:19 +0100 Subject: [PATCH 016/190] Create log files when running node with `--initialize` --- nano/node/cli.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 26fe004923..4bb19c8747 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -254,6 +254,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (vm.count ("initialize")) { + // TODO: --config flag overrides are not taken into account here + nano::nlogger::initialize (nano::log_config::daemon_default (), data_path); + auto node_flags = nano::inactive_node_flag_defaults (); node_flags.read_only = false; nano::update_flags (node_flags, vm); From f42beb8d0357ef2ee2772913000dfaa6f5b27dc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 19 Jan 2024 14:48:16 +0100 Subject: [PATCH 017/190] Fix `wallet.import` test --- nano/qt_test/qt.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index b69559b353..8735ef9a06 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -685,7 +685,7 @@ TEST (wallet, import) system.wallet (0)->store.serialize_json (transaction, json); } system.wallet (1)->insert_adhoc (key2.prv); - auto path (nano::unique_path ()); + auto path{ nano::unique_path () / "wallet.json" }; { std::ofstream stream; stream.open (path.string ().c_str ()); From f4fee1dd67c73dde0a352fb0b8ef52e665d08891 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 19 Jan 2024 14:53:59 +0100 Subject: [PATCH 018/190] Rename back to `nano::logger` --- nano/core_test/block_store.cpp | 96 +++++++++---------- nano/core_test/bootstrap_ascending.cpp | 20 ++-- nano/core_test/confirmation_height.cpp | 10 +- nano/core_test/core_test_main.cc | 2 +- nano/core_test/ledger.cpp | 24 ++--- nano/core_test/node.cpp | 2 +- nano/core_test/processor_service.cpp | 4 +- nano/core_test/work_pool.cpp | 2 +- nano/lib/logging.cpp | 30 +++--- nano/lib/logging.hpp | 8 +- nano/lib/tlsconfig.cpp | 4 +- nano/lib/tlsconfig.hpp | 4 +- nano/load_test/entry.cpp | 2 +- nano/nano_node/daemon.cpp | 38 ++++---- nano/nano_node/daemon.hpp | 2 +- nano/nano_node/entry.cpp | 16 ++-- nano/nano_rpc/entry.cpp | 16 ++-- nano/nano_wallet/entry.cpp | 16 ++-- nano/node/blockprocessor.cpp | 10 +- nano/node/bootstrap/bootstrap_attempt.cpp | 4 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 40 ++++---- nano/node/bootstrap/bootstrap_bulk_push.cpp | 16 ++-- nano/node/bootstrap/bootstrap_connections.cpp | 16 ++-- nano/node/bootstrap/bootstrap_frontier.cpp | 18 ++-- nano/node/bootstrap/bootstrap_lazy.cpp | 6 +- nano/node/bootstrap/bootstrap_legacy.cpp | 6 +- nano/node/cli.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 8 +- nano/node/confirmation_height_bounded.hpp | 4 +- nano/node/confirmation_height_processor.cpp | 6 +- nano/node/confirmation_height_processor.hpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 8 +- nano/node/confirmation_height_unbounded.hpp | 4 +- nano/node/distributed_work.cpp | 26 ++--- nano/node/epoch_upgrader.cpp | 16 ++-- nano/node/epoch_upgrader.hpp | 4 +- nano/node/gap_cache.cpp | 2 +- nano/node/ipc/ipc_broker.cpp | 12 +-- nano/node/ipc/ipc_server.cpp | 34 +++---- nano/node/json_handler.cpp | 4 +- nano/node/make_store.cpp | 2 +- nano/node/make_store.hpp | 2 +- nano/node/network.cpp | 10 +- nano/node/node.cpp | 94 +++++++++--------- nano/node/node.hpp | 2 +- nano/node/openclwork.cpp | 54 +++++------ nano/node/openclwork.hpp | 8 +- nano/node/portmapping.cpp | 24 ++--- nano/node/repcrawler.cpp | 8 +- nano/node/transport/socket.cpp | 4 +- nano/node/transport/tcp.cpp | 18 ++-- nano/node/transport/tcp_server.cpp | 42 ++++---- nano/node/vote_processor.cpp | 8 +- nano/node/vote_processor.hpp | 6 +- nano/node/wallet.cpp | 26 ++--- nano/node/websocket.cpp | 66 ++++++------- nano/node/websocket.hpp | 22 ++--- nano/qt/qt.cpp | 4 +- nano/qt_test/entry.cpp | 2 +- nano/qt_test/qt.cpp | 8 +- nano/rpc/rpc.cpp | 8 +- nano/rpc/rpc.hpp | 2 +- nano/rpc/rpc_connection.cpp | 12 +-- nano/rpc/rpc_connection.hpp | 4 +- nano/rpc/rpc_handler.cpp | 6 +- nano/rpc/rpc_handler.hpp | 4 +- nano/rpc/rpc_secure.cpp | 4 +- nano/rpc_test/entry.cpp | 2 +- nano/secure/ledger.cpp | 4 +- nano/slow_test/entry.cpp | 2 +- nano/slow_test/node.cpp | 6 +- nano/store/lmdb/lmdb.cpp | 34 +++---- nano/store/lmdb/lmdb.hpp | 6 +- nano/store/lmdb/transaction.cpp | 6 +- nano/store/lmdb/transaction_impl.hpp | 4 +- nano/store/rocksdb/rocksdb.cpp | 20 ++-- nano/store/rocksdb/rocksdb.hpp | 4 +- nano/test_common/ledger.cpp | 2 +- nano/test_common/ledger.hpp | 2 +- nano/test_common/system.hpp | 2 +- 80 files changed, 544 insertions(+), 544 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index fa2bd3286b..fe6d90c40c 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -27,7 +27,7 @@ using namespace std::chrono_literals; TEST (block_store, construction) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); } @@ -102,7 +102,7 @@ TEST (block_store, sideband_serialization) TEST (block_store, add_item) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -133,7 +133,7 @@ TEST (block_store, add_item) TEST (block_store, clear_successor) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -180,7 +180,7 @@ TEST (block_store, clear_successor) TEST (block_store, add_nonempty_block) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -207,7 +207,7 @@ TEST (block_store, add_nonempty_block) TEST (block_store, add_two_items) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -253,7 +253,7 @@ TEST (block_store, add_two_items) TEST (block_store, add_receive) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -289,7 +289,7 @@ TEST (block_store, add_receive) TEST (block_store, add_pending) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -307,7 +307,7 @@ TEST (block_store, add_pending) TEST (block_store, pending_iterator) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -332,7 +332,7 @@ TEST (block_store, pending_iterator) */ TEST (block_store, pending_iterator_comparison) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -375,7 +375,7 @@ TEST (block_store, pending_iterator_comparison) TEST (block_store, genesis) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger_cache ledger_cache; @@ -403,7 +403,7 @@ TEST (block_store, genesis) TEST (block_store, empty_accounts) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); @@ -414,7 +414,7 @@ TEST (block_store, empty_accounts) TEST (block_store, one_block) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -435,7 +435,7 @@ TEST (block_store, one_block) TEST (block_store, empty_bootstrap) { nano::test::system system{}; - nano::nlogger logger; + nano::logger logger; nano::unchecked_map unchecked{ system.stats, false }; size_t count = 0; unchecked.for_each ([&count] (nano::unchecked_key const & key, nano::unchecked_info const & info) { @@ -446,7 +446,7 @@ TEST (block_store, empty_bootstrap) TEST (block_store, unchecked_begin_search) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key0; @@ -471,7 +471,7 @@ TEST (block_store, unchecked_begin_search) TEST (block_store, frontier_retrieval) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1{}; @@ -486,7 +486,7 @@ TEST (block_store, frontier_retrieval) TEST (block_store, one_account) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account{}; @@ -513,7 +513,7 @@ TEST (block_store, one_account) TEST (block_store, two_block) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -551,7 +551,7 @@ TEST (block_store, two_block) TEST (block_store, two_account) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); @@ -593,7 +593,7 @@ TEST (block_store, two_account) TEST (block_store, latest_find) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); @@ -627,7 +627,7 @@ TEST (mdb_block_store, supported_version_upgrades) } // Check that upgrading from an unsupported version is not supported auto path (nano::unique_path () / "data.ldb"); - nano::nlogger logger; + nano::logger logger; { nano::store::lmdb::component store (logger, path, nano::dev::constants); nano::stats stats; @@ -671,7 +671,7 @@ TEST (mdb_block_store, bad_path) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::nlogger logger; + nano::logger logger; try { auto path = nano::unique_path (); @@ -697,14 +697,14 @@ TEST (block_store, DISABLED_already_open) // File can be shared std::ofstream file; file.open (path.string ().c_str ()); ASSERT_TRUE (file.is_open ()); - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (store->init_error ()); } TEST (block_store, roots) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -746,7 +746,7 @@ TEST (block_store, roots) TEST (block_store, pending_exists) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::pending_key two (2, 0); @@ -759,7 +759,7 @@ TEST (block_store, pending_exists) TEST (block_store, latest_exists) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account two (2); @@ -773,7 +773,7 @@ TEST (block_store, latest_exists) TEST (block_store, large_iteration) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); std::unordered_set accounts1; @@ -812,7 +812,7 @@ TEST (block_store, large_iteration) TEST (block_store, frontier) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -827,7 +827,7 @@ TEST (block_store, frontier) TEST (block_store, block_replace) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -859,7 +859,7 @@ TEST (block_store, block_replace) TEST (block_store, block_count) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { @@ -884,7 +884,7 @@ TEST (block_store, block_count) TEST (block_store, account_count) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { @@ -900,7 +900,7 @@ TEST (block_store, account_count) TEST (block_store, cemented_count_cache) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); @@ -911,7 +911,7 @@ TEST (block_store, cemented_count_cache) TEST (block_store, block_random) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); { nano::ledger_cache ledger_cache; @@ -926,7 +926,7 @@ TEST (block_store, block_random) TEST (block_store, pruned_random) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; @@ -953,7 +953,7 @@ TEST (block_store, pruned_random) TEST (block_store, state_block) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::keypair key1; @@ -1000,7 +1000,7 @@ TEST (mdb_block_store, sideband_height) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::nlogger logger; + nano::logger logger; nano::keypair key1; nano::keypair key2; nano::keypair key3; @@ -1153,7 +1153,7 @@ TEST (mdb_block_store, sideband_height) TEST (block_store, peers) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1251,7 +1251,7 @@ TEST (block_store, endpoint_key_byte_order) TEST (block_store, online_weight) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); { @@ -1286,7 +1286,7 @@ TEST (block_store, online_weight) TEST (block_store, pruned_blocks) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1373,7 +1373,7 @@ TEST (mdb_block_store, upgrade_v21_v22) } auto path (nano::unique_path () / "data.ldb"); - nano::nlogger logger; + nano::logger logger; nano::stats stats; auto const check_correct_state = [&] () { nano::store::lmdb::component store (logger, path, nano::dev::constants); @@ -1412,7 +1412,7 @@ TEST (rocksdb_block_store, upgrade_v21_v22) } auto const path = nano::unique_path () / "rocksdb"; - nano::nlogger logger; + nano::logger logger; nano::stats stats; auto const check_correct_state = [&] () { nano::store::rocksdb::component store (logger, path, nano::dev::constants); @@ -1472,7 +1472,7 @@ TEST (mdb_block_store, upgrade_backup) }; { - nano::nlogger logger; + nano::logger logger; nano::store::lmdb::component store (logger, path, nano::dev::constants); auto transaction (store.tx_begin_write ()); store.version.put (transaction, store.version_minimum); @@ -1480,7 +1480,7 @@ TEST (mdb_block_store, upgrade_backup) ASSERT_EQ (get_backup_path ().string (), dir.string ()); // Now do the upgrade and confirm that backup is saved - nano::nlogger logger; + nano::logger logger; nano::store::lmdb::component store (logger, path, nano::dev::constants, nano::txn_tracking_config{}, std::chrono::seconds (5), nano::lmdb_config{}, true); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); @@ -1497,7 +1497,7 @@ TEST (block_store, confirmation_height) GTEST_SKIP (); } auto path (nano::unique_path ()); - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, path, nano::dev::constants); nano::account account1{}; @@ -1543,7 +1543,7 @@ TEST (block_store, final_vote) GTEST_SKIP (); } auto path (nano::unique_path ()); - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, path, nano::dev::constants); { @@ -1568,7 +1568,7 @@ TEST (block_store, final_vote) TEST (block_store, incompatible_version) { auto path (nano::unique_path ()); - nano::nlogger logger; + nano::logger logger; { auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_FALSE (store->init_error ()); @@ -1591,7 +1591,7 @@ TEST (block_store, incompatible_version) TEST (block_store, reset_renew_existing_transaction) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1631,7 +1631,7 @@ TEST (block_store, reset_renew_existing_transaction) TEST (block_store, rocksdb_force_test_env_variable) { - nano::nlogger logger; + nano::logger logger; // Set environment variable constexpr auto env_var = "TEST_USE_ROCKSDB"; @@ -1661,7 +1661,7 @@ TEST (rocksdb_block_store, tombstone_count) GTEST_SKIP (); } nano::test::system system; - nano::nlogger logger; + nano::logger logger; auto store = std::make_unique (logger, nano::unique_path () / "rocksdb", nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::block_builder builder; diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index 7599ed5c5f..49b8ed299d 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -25,7 +25,7 @@ nano::block_hash random_hash () TEST (account_sets, construction) { nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -35,7 +35,7 @@ TEST (account_sets, empty_blocked) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -46,7 +46,7 @@ TEST (account_sets, block) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -58,7 +58,7 @@ TEST (account_sets, unblock) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -72,7 +72,7 @@ TEST (account_sets, priority_base) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -83,7 +83,7 @@ TEST (account_sets, priority_blocked) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -96,7 +96,7 @@ TEST (account_sets, priority_unblock_keep) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -114,7 +114,7 @@ TEST (account_sets, priority_up_down) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -129,7 +129,7 @@ TEST (account_sets, priority_down_sat) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; @@ -142,7 +142,7 @@ TEST (account_sets, saturate_priority) { nano::account account{ 1 }; nano::stats stats; - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::bootstrap_ascending::account_sets sets{ stats }; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index aaba8735fa..2271e4985c 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1158,7 +1158,7 @@ TEST (confirmation_heightDeathTest, rollback_added_block) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1249,7 +1249,7 @@ TEST (confirmation_heightDeathTest, modified_chain) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -1326,7 +1326,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) // valgrind can be noisy with death tests if (!nano::running_within_valgrind ()) { - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -2037,7 +2037,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); @@ -2100,7 +2100,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) TEST (confirmation_height, pruned_source) { - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index f165199a83..0abd1cdc3a 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -19,7 +19,7 @@ void force_nano_dev_network (); GTEST_API_ int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); + nano::logger::initialize_for_tests (nano::log_config::tests_default ()); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 70841d5eee..efe7a05ab0 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -818,7 +818,7 @@ TEST (ledger, representation) TEST (ledger, double_open) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -4162,7 +4162,7 @@ TEST (ledger, block_hash_account_conflict) TEST (ledger, could_fit) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -4800,7 +4800,7 @@ TEST (ledger, dependents_confirmed) TEST (ledger, dependents_confirmed_pruning) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -4990,7 +4990,7 @@ TEST (ledger, cache) TEST (ledger, pruning_action) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5074,7 +5074,7 @@ TEST (ledger, pruning_action) TEST (ledger, pruning_large_chain) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5129,7 +5129,7 @@ TEST (ledger, pruning_large_chain) TEST (ledger, pruning_source_rollback) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5217,7 +5217,7 @@ TEST (ledger, pruning_source_rollback) TEST (ledger, pruning_source_rollback_legacy) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5330,7 +5330,7 @@ TEST (ledger, pruning_source_rollback_legacy) TEST (ledger, pruning_process_error) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5377,7 +5377,7 @@ TEST (ledger, pruning_process_error) TEST (ledger, pruning_legacy_blocks) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5463,7 +5463,7 @@ TEST (ledger, pruning_legacy_blocks) TEST (ledger, pruning_safe_functions) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5524,7 +5524,7 @@ TEST (ledger, pruning_safe_functions) TEST (ledger, hash_root_random) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stats stats; @@ -5588,7 +5588,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) { nano::test::system system{}; auto path = nano::unique_path (); - nano::nlogger logger; + nano::logger logger; boost::asio::ip::address_v6 address (boost::asio::ip::make_address_v6 ("::ffff:127.0.0.1")); uint16_t port = 100; nano::store::lmdb::component store{ logger, path / "data.ldb", nano::dev::constants }; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index c6f8861c1d..127ba46f90 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3296,7 +3296,7 @@ TEST (node, dont_write_lock_node) std::promise write_lock_held_promise; std::promise finished_promise; std::thread ([&path, &write_lock_held_promise, &finished_promise] () { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, path, nano::dev::constants, false, true); { nano::ledger_cache ledger_cache; diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 6e48598762..406e2ed47d 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -11,7 +11,7 @@ TEST (processor_service, bad_send_signature) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -37,7 +37,7 @@ TEST (processor_service, bad_send_signature) TEST (processor_service, bad_receive_signature) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 1c429ca3a9..59ada8938c 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -89,7 +89,7 @@ TEST (work, cancel_many) TEST (work, opencl) { - nano::nlogger logger; + nano::logger logger; bool error (false); nano::opencl_environment environment (error); ASSERT_TRUE (!error || !nano::opencl_loaded); diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 8f491850b0..f24c2e8ed8 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -15,26 +15,26 @@ namespace std::atomic logging_initialized{ false }; } -nano::nlogger & nano::default_logger () +nano::logger & nano::default_logger () { - static nano::nlogger logger{ "default" }; + static nano::logger logger{ "default" }; return logger; } /* - * nlogger + * logger */ -bool nano::nlogger::global_initialized{ false }; -nano::log_config nano::nlogger::global_config{}; -std::vector nano::nlogger::global_sinks{}; +bool nano::logger::global_initialized{ false }; +nano::log_config nano::logger::global_config{}; +std::vector nano::logger::global_sinks{}; // By default, use only the tag as the logger name, since only one node is running in the process -std::function nano::nlogger::global_name_formatter{ [] (auto tag, auto identifier) { +std::function nano::logger::global_name_formatter{ [] (auto tag, auto identifier) { return std::string{ to_string (tag) }; } }; -void nano::nlogger::initialize (nano::log_config fallback, std::filesystem::path data_path, std::vector const & config_overrides) +void nano::logger::initialize (nano::log_config fallback, std::filesystem::path data_path, std::vector const & config_overrides) { auto config = nano::load_log_config (std::move (fallback), data_path, config_overrides); initialize_common (config, data_path); @@ -95,7 +95,7 @@ class tag_formatter_flag : public spdlog::custom_flag_formatter }; } -void nano::nlogger::initialize_for_tests (nano::log_config fallback) +void nano::logger::initialize_for_tests (nano::log_config fallback) { auto config = nano::load_log_config (std::move (fallback), /* load log config from current workdir */ {}); initialize_common (config, /* store log file in current workdir */ {}); @@ -119,7 +119,7 @@ void nano::nlogger::initialize_for_tests (nano::log_config fallback) global_initialized = true; } -void nano::nlogger::initialize_common (nano::log_config const & config, std::filesystem::path data_path) +void nano::logger::initialize_common (nano::log_config const & config, std::filesystem::path data_path) { global_config = config; @@ -183,7 +183,7 @@ void nano::nlogger::initialize_common (nano::log_config const & config, std::fil } } -void nano::nlogger::flush () +void nano::logger::flush () { for (auto & sink : global_sinks) { @@ -192,15 +192,15 @@ void nano::nlogger::flush () } /* - * nlogger + * logger */ -nano::nlogger::nlogger (std::string identifier) : +nano::logger::logger (std::string identifier) : identifier{ std::move (identifier) } { } -spdlog::logger & nano::nlogger::get_logger (nano::log::type tag) +spdlog::logger & nano::logger::get_logger (nano::log::type tag) { // This is a two-step process to avoid exclusively locking the mutex in the common case { @@ -220,7 +220,7 @@ spdlog::logger & nano::nlogger::get_logger (nano::log::type tag) } } -std::shared_ptr nano::nlogger::make_logger (nano::log::type tag) +std::shared_ptr nano::logger::make_logger (nano::log::type tag) { auto const & config = global_config; auto const & sinks = global_sinks; diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 1c23d49ba2..4844cda40b 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -67,13 +67,13 @@ namespace nano { spdlog::level::level_enum to_spdlog_level (nano::log::level); -class nlogger final +class logger final { public: - nlogger (std::string identifier = ""); + logger (std::string identifier = ""); // Disallow copies - nlogger (nlogger const &) = delete; + logger (logger const &) = delete; public: static void initialize (nano::log_config fallback, std::filesystem::path data_path = {}, std::vector const & config_overrides = std::vector ()); @@ -136,5 +136,5 @@ class nlogger final std::shared_ptr make_logger (nano::log::type tag); }; -nano::nlogger & default_logger (); +nano::logger & default_logger (); } \ No newline at end of file diff --git a/nano/lib/tlsconfig.cpp b/nano/lib/tlsconfig.cpp index 898103763b..9af33384b4 100644 --- a/nano/lib/tlsconfig.cpp +++ b/nano/lib/tlsconfig.cpp @@ -138,7 +138,7 @@ namespace } #endif -nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::nlogger & nlogger, std::vector const & config_overrides) +nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger & logger, std::vector const & config_overrides) { nano::error error; auto toml_config_path = nano::get_tls_toml_config_path (data_path_a); @@ -176,7 +176,7 @@ nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nan #ifdef NANO_SECURE_RPC load_certs (config_a, logger_a); #else - nlogger.critical (nano::log::type::tls, "HTTPS or WSS is enabled in the TLS configuration, but the node is not built with NANO_SECURE_RPC"); + logger.critical (nano::log::type::tls, "HTTPS or WSS is enabled in the TLS configuration, but the node is not built with NANO_SECURE_RPC"); std::exit (1); #endif } diff --git a/nano/lib/tlsconfig.hpp b/nano/lib/tlsconfig.hpp index d7d18f4202..bae2a9f9b2 100644 --- a/nano/lib/tlsconfig.hpp +++ b/nano/lib/tlsconfig.hpp @@ -13,7 +13,7 @@ namespace nano { -class nlogger; +class logger; class jsonconfig; class tomlconfig; @@ -54,5 +54,5 @@ class tls_config final #endif }; -nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::nlogger &, std::vector const & config_overrides = std::vector ()); +nano::error read_tls_config_toml (std::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger &, std::vector const & config_overrides = std::vector ()); } diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index a159d05cd8..e41e376abc 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -491,7 +491,7 @@ account_info account_info_rpc (boost::asio::io_context & ioc, tcp::resolver::res /** This launches a node and fires a lot of send/recieve RPC requests at it (configurable), then other nodes are tested to make sure they observe these blocks as well. */ int main (int argc, char * const * argv) { - nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); + nano::logger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); boost::program_options::options_description description ("Command line options"); diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 728cd5ad0d..fed22d3bcf 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -63,9 +63,9 @@ constexpr std::size_t OPEN_FILE_DESCRIPTORS_LIMIT = 16384; void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flags const & flags) { - nano::nlogger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); + nano::logger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); - nlogger.info (nano::log::type::daemon, "Daemon started"); + logger.info (nano::log::type::daemon, "Daemon started"); install_abort_signal_handler (); @@ -87,7 +87,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag if (!error) { auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); if (error) { std::cerr << error.get_message () << std::endl; @@ -99,7 +99,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag } boost::asio::io_context io_ctx; - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, nlogger, config.node.network_params.work)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); } @@ -107,17 +107,17 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag try { // This avoids a blank prompt during any node initialization delays - nlogger.info (nano::log::type::daemon, "Starting up Nano node..."); + logger.info (nano::log::type::daemon, "Starting up Nano node..."); // Print info about number of logical cores detected, those are used to decide how many IO, worker and signature checker threads to spawn - nlogger.info (nano::log::type::daemon, "Hardware concurrency: {} ( configured: {} )", std::thread::hardware_concurrency (), nano::hardware_concurrency ()); + logger.info (nano::log::type::daemon, "Hardware concurrency: {} ( configured: {} )", std::thread::hardware_concurrency (), nano::hardware_concurrency ()); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); auto const file_descriptor_limit = nano::get_file_descriptor_limit (); - nlogger.info (nano::log::type::daemon, "File descriptors limit: {}", file_descriptor_limit); + logger.info (nano::log::type::daemon, "File descriptors limit: {}", file_descriptor_limit); if (file_descriptor_limit < OPEN_FILE_DESCRIPTORS_LIMIT) { - nlogger.warn (nano::log::type::daemon, "File descriptors limit is lower than the {} recommended. Node was unable to change it.", OPEN_FILE_DESCRIPTORS_LIMIT); + logger.warn (nano::log::type::daemon, "File descriptors limit is lower than the {} recommended. Node was unable to change it.", OPEN_FILE_DESCRIPTORS_LIMIT); } // for the daemon start up, if the user hasn't specified a port in @@ -134,12 +134,12 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag auto network_label = node->network_params.network.get_current_network_as_string (); std::time_t dateTime = std::time (nullptr); - nlogger.info (nano::log::type::daemon, "Network: {}", network_label); - nlogger.info (nano::log::type::daemon, "Version: {}", NANO_VERSION_STRING); - nlogger.info (nano::log::type::daemon, "Data path: '{}'", node->application_path.string ()); - nlogger.info (nano::log::type::daemon, "Build info: {}", BUILD_INFO); - nlogger.info (nano::log::type::daemon, "Database backend: {}", node->store.vendor_get ()); - nlogger.info (nano::log::type::daemon, "Start time: {:%c} UTC", fmt::gmtime (dateTime)); + logger.info (nano::log::type::daemon, "Network: {}", network_label); + logger.info (nano::log::type::daemon, "Version: {}", NANO_VERSION_STRING); + logger.info (nano::log::type::daemon, "Data path: '{}'", node->application_path.string ()); + logger.info (nano::log::type::daemon, "Build info: {}", BUILD_INFO); + logger.info (nano::log::type::daemon, "Database backend: {}", node->store.vendor_get ()); + logger.info (nano::log::type::daemon, "Start time: {:%c} UTC", fmt::gmtime (dateTime)); node->start (); @@ -186,7 +186,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag debug_assert (!nano::signal_handler_impl); nano::signal_handler_impl = [this, &io_ctx] () { - nlogger.warn (nano::log::type::daemon, "Interrupt signal received, stopping..."); + logger.warn (nano::log::type::daemon, "Interrupt signal received, stopping..."); io_ctx.stop (); sig_int_or_term = 1; @@ -219,18 +219,18 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag } else { - nlogger.critical (nano::log::type::daemon, "Error initializing node"); + logger.critical (nano::log::type::daemon, "Error initializing node"); } } catch (std::runtime_error const & e) { - nlogger.critical (nano::log::type::daemon, "Error while running node: {}", e.what ()); + logger.critical (nano::log::type::daemon, "Error while running node: {}", e.what ()); } } else { - nlogger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); + logger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); } - nlogger.info (nano::log::type::daemon, "Daemon exiting"); + logger.info (nano::log::type::daemon, "Daemon exiting"); } diff --git a/nano/nano_node/daemon.hpp b/nano/nano_node/daemon.hpp index b3d365ce39..8fcc69787c 100644 --- a/nano/nano_node/daemon.hpp +++ b/nano/nano_node/daemon.hpp @@ -6,7 +6,7 @@ class node_flags; class daemon { - nano::nlogger nlogger{ "daemon" }; + nano::logger logger{ "daemon" }; public: void run (std::filesystem::path const &, nano::node_flags const & flags); diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index bee3d44e06..e77751762e 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -54,7 +54,7 @@ class address_library_pair int main (int argc, char * const * argv) { nano::set_umask (); // Make sure the process umask is set before any files are created - nano::nlogger::initialize (nano::log_config::cli_default ()); + nano::logger::initialize (nano::log_config::cli_default ()); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; @@ -613,9 +613,9 @@ int main (int argc, char * const * argv) error |= device >= environment.platforms[platform].devices.size (); if (!error) { - nano::nlogger nlogger; + nano::logger logger; nano::opencl_config config (platform, device, threads); - auto opencl (nano::opencl_work::create (true, config, nlogger, network_params.work)); + auto opencl (nano::opencl_work::create (true, config, logger, network_params.work)); nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } @@ -1881,11 +1881,11 @@ int main (int argc, char * const * argv) else if (vm.count ("debug_sys_logging")) { auto inactive_node = nano::default_inactive_node (data_path, vm); - inactive_node->node->nlogger.critical ({}, "Testing system logger (CRITICAL)"); - inactive_node->node->nlogger.error ({}, "Testing system logger (ERROR)"); - inactive_node->node->nlogger.warn ({}, "Testing system logger (WARN)"); - inactive_node->node->nlogger.info ({}, "Testing system logger (INFO)"); - inactive_node->node->nlogger.debug ({}, "Testing system logger (DEBUG)"); + inactive_node->node->logger.critical ({}, "Testing system logger (CRITICAL)"); + inactive_node->node->logger.error ({}, "Testing system logger (ERROR)"); + inactive_node->node->logger.warn ({}, "Testing system logger (WARN)"); + inactive_node->node->logger.info ({}, "Testing system logger (INFO)"); + inactive_node->node->logger.debug ({}, "Testing system logger (DEBUG)"); } else if (vm.count ("debug_account_versions")) { diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp index 1238c95ce3..65e1de81e9 100644 --- a/nano/nano_rpc/entry.cpp +++ b/nano/nano_rpc/entry.cpp @@ -19,11 +19,11 @@ namespace { volatile sig_atomic_t sig_int_or_term = 0; -nano::nlogger nlogger{ "rpc_daemon" }; +nano::logger logger{ "rpc_daemon" }; void run (std::filesystem::path const & data_path, std::vector const & config_overrides) { - nlogger.info (nano::log::type::daemon_rpc, "Daemon started (RPC)"); + logger.info (nano::log::type::daemon_rpc, "Daemon started (RPC)"); std::filesystem::create_directories (data_path); @@ -38,10 +38,10 @@ void run (std::filesystem::path const & data_path, std::vector cons if (!error) { auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); if (error) { - nlogger.critical (nano::log::type::daemon, "Error reading RPC TLS config: {}", error.get_message ()); + logger.critical (nano::log::type::daemon, "Error reading RPC TLS config: {}", error.get_message ()); std::exit (1); } else @@ -76,22 +76,22 @@ void run (std::filesystem::path const & data_path, std::vector cons } catch (std::runtime_error const & e) { - nlogger.critical (nano::log::type::daemon, "Error while running RPC: {}", e.what ()); + logger.critical (nano::log::type::daemon, "Error while running RPC: {}", e.what ()); } } else { - nlogger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); + logger.critical (nano::log::type::daemon, "Error deserializing config: {}", error.get_message ()); } - nlogger.info (nano::log::type::daemon_rpc, "Daemon stopped (RPC)"); + logger.info (nano::log::type::daemon_rpc, "Daemon stopped (RPC)"); } } int main (int argc, char * const * argv) { nano::set_umask (); // Make sure the process umask is set before any files are created - nano::nlogger::initialize (nano::log_config::cli_default ()); + nano::logger::initialize (nano::log_config::cli_default ()); boost::program_options::options_description description ("Command line options"); diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 3c863c06f1..ec15e6fb98 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -26,11 +26,11 @@ namespace { -nano::nlogger nlogger{ "wallet_daemon" }; +nano::logger logger{ "wallet_daemon" }; void show_error (std::string const & message_a) { - nlogger.critical (nano::log::type::daemon, "{}", message_a); + logger.critical (nano::log::type::daemon, "{}", message_a); QMessageBox message (QMessageBox::Critical, "Error starting Nano", message_a.c_str ()); message.setModal (true); @@ -74,9 +74,9 @@ nano::error read_wallet_config (nano::wallet_config & config_a, std::filesystem: int run_wallet (QApplication & application, int argc, char * const * argv, std::filesystem::path const & data_path, nano::node_flags const & flags) { - nano::nlogger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); + nano::logger::initialize (nano::log_config::daemon_default (), data_path, flags.config_overrides); - nlogger.info (nano::log::type::daemon_wallet, "Daemon started (wallet)"); + logger.info (nano::log::type::daemon_wallet, "Daemon started (wallet)"); int result (0); nano_qt::eventloop_processor processor; @@ -110,7 +110,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: nano::set_use_memory_pools (config.node.use_memory_pools); auto tls_config (std::make_shared ()); - error = nano::read_tls_config_toml (data_path, *tls_config, nlogger); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); if (error) { splash->hide (); @@ -128,7 +128,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: std::shared_ptr node; std::shared_ptr gui; nano::set_application_icon (application); - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, nlogger, config.node.network_params.work)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } @@ -239,7 +239,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: show_error ("Error deserializing config: " + error.get_message ()); } - nlogger.info (nano::log::type::daemon_wallet, "Daemon exiting (wallet)"); + logger.info (nano::log::type::daemon_wallet, "Daemon exiting (wallet)"); return result; } @@ -247,7 +247,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: int main (int argc, char * const * argv) { nano::set_umask (); // Make sure the process umask is set before any files are created - nano::nlogger::initialize (nano::log_config::cli_default ()); + nano::logger::initialize (nano::log_config::cli_default ()); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index f5667628ff..e696b5966b 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -112,17 +112,17 @@ void nano::block_processor::rollback_competitor (store::write_transaction const if (successor != nullptr && successor->hash () != hash) { // Replace our block with the winner and roll back any dependent blocks - node.nlogger.debug (nano::log::type::blockprocessor, "Rolling back: {} and replacing with: {}", successor->hash ().to_string (), hash.to_string ()); + node.logger.debug (nano::log::type::blockprocessor, "Rolling back: {} and replacing with: {}", successor->hash ().to_string (), hash.to_string ()); std::vector> rollback_list; if (node.ledger.rollback (transaction, successor->hash (), rollback_list)) { node.stats.inc (nano::stat::type::ledger, nano::stat::detail::rollback_failed); - node.nlogger.error (nano::log::type::blockprocessor, "Failed to roll back: {} because it or a successor was confirmed", successor->hash ().to_string ()); + node.logger.error (nano::log::type::blockprocessor, "Failed to roll back: {} because it or a successor was confirmed", successor->hash ().to_string ()); } else { - node.nlogger.debug (nano::log::type::blockprocessor, "Blocks rolled back: {}", rollback_list.size ()); + node.logger.debug (nano::log::type::blockprocessor, "Blocks rolled back: {}", rollback_list.size ()); } // Deleting from votes cache, stop active transaction for (auto & i : rollback_list) @@ -219,7 +219,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock // TODO: Cleaner periodical logging if ((blocks.size () + forced.size () > 64) && should_log ()) { - node.nlogger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); + node.logger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); } std::shared_ptr block; @@ -253,7 +253,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock if (number_of_blocks_processed != 0 && timer_l.stop () > std::chrono::milliseconds (100)) { - node.nlogger.debug (nano::log::type::blockprocessor, "Processed {} blocks ({} forced) in {} {}", number_of_blocks_processed, number_of_forced_processed, timer_l.value ().count (), timer_l.unit ()); + node.logger.debug (nano::log::type::blockprocessor, "Processed {} blocks ({} forced) in {} {}", number_of_blocks_processed, number_of_forced_processed, timer_l.value ().count (), timer_l.unit ()); } return processed; diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 0502c943ae..8d892db2e2 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -20,7 +20,7 @@ nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr const & id = nano::hardened_constants::get ().random_128.to_string (); } - node_a->nlogger.debug (nano::log::type::bootstrap, "Starting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); + node_a->logger.debug (nano::log::type::bootstrap, "Starting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); node_a->bootstrap_initiator.notify_listeners (true); if (node_a->websocket.server) @@ -38,7 +38,7 @@ nano::bootstrap_attempt::~bootstrap_attempt () return; } - node->nlogger.debug (nano::log::type::bootstrap, "Exiting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); + node->logger.debug (nano::log::type::bootstrap, "Exiting bootstrap attempt with ID: {} (mode: {})", mode_text (), id); node->bootstrap_initiator.notify_listeners (false); if (node->websocket.server) diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 19538bbcd6..33fb6717a2 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -47,7 +47,7 @@ nano::bulk_pull_client::~bulk_pull_client () pull.processed += pull_blocks - unexpected_count; node->bootstrap_initiator.connections->requeue_pull (pull, network_error); - node->nlogger.debug (nano::log::type::bulk_pull_client, "Bulk pull end block is not expected {} for account {} or head block {}", pull.end.to_string (), pull.account_or_head.to_account (), pull.account_or_head.to_string ()); + node->logger.debug (nano::log::type::bulk_pull_client, "Bulk pull end block is not expected {} for account {} or head block {}", pull.end.to_string (), pull.account_or_head.to_account (), pull.account_or_head.to_string ()); } else { @@ -82,7 +82,7 @@ void nano::bulk_pull_client::request () if (attempt->should_log ()) { - node->nlogger.debug (nano::log::type::bulk_pull_client, "Accounts in pull queue: {}", attempt->pulling.load ()); + node->logger.debug (nano::log::type::bulk_pull_client, "Accounts in pull queue: {}", attempt->pulling.load ()); } auto this_l (shared_from_this ()); @@ -99,7 +99,7 @@ void nano::bulk_pull_client::request () } else { - node->nlogger.debug (nano::log::type::bulk_pull_client, "Error sending bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_client, "Error sending bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_request_failure, nano::stat::dir::in); } }, @@ -160,7 +160,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: } if (node->network_params.work.validate_entry (*block)) { - node->nlogger.debug (nano::log::type::bulk_pull_client, "Insufficient work for bulk pull block: {}", block->hash ().to_string ()); + node->logger.debug (nano::log::type::bulk_pull_client, "Insufficient work for bulk pull block: {}", block->hash ().to_string ()); node->stats.inc (nano::stat::type::error, nano::stat::detail::insufficient_work); return; } @@ -234,7 +234,7 @@ void nano::bulk_pull_account_client::request () if (attempt->should_log ()) { - node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Accounts in pull queue: {}", attempt->wallet_size ()); + node->logger.debug (nano::log::type::bulk_pull_account_client, "Accounts in pull queue: {}", attempt->wallet_size ()); } auto this_l (shared_from_this ()); @@ -251,7 +251,7 @@ void nano::bulk_pull_account_client::request () } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Error starting bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_account_client, "Error starting bulk pull request to: {} ({})", this_l->connection->channel->to_string (), ec.message ()); node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_error_starting_request, nano::stat::dir::in); this_l->attempt->requeue_pending (this_l->account); @@ -314,14 +314,14 @@ void nano::bulk_pull_account_client::receive_pending () } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Error while receiving bulk pull account frontier: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_account_client, "Error while receiving bulk pull account frontier: {}", ec.message ()); this_l->attempt->requeue_pending (this_l->account); } } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_client, "Invalid size: Expected {}, got: {}", size_l, size_a); + node->logger.debug (nano::log::type::bulk_pull_account_client, "Invalid size: Expected {}, got: {}", size_l, size_a); this_l->attempt->requeue_pending (this_l->account); } @@ -355,14 +355,14 @@ void nano::bulk_pull_server::set_current_end () auto transaction (node->store.tx_begin_read ()); if (!node->store.block.exists (transaction, request->end)) { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk pull end block doesn't exist: {}, sending everything", request->end.to_string ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Bulk pull end block doesn't exist: {}, sending everything", request->end.to_string ()); request->end.clear (); } if (node->store.block.exists (transaction, request->start.as_block_hash ())) { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk pull request for block hash: {}", request->start.to_string ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Bulk pull request for block hash: {}", request->start.to_string ()); current = ascending () ? node->store.block.successor (transaction, request->start.as_block_hash ()) : request->start.as_block_hash (); include_start = true; @@ -372,7 +372,7 @@ void nano::bulk_pull_server::set_current_end () auto info = node->ledger.account_info (transaction, request->start.as_account ()); if (!info) { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Request for unknown account: {}", request->start.to_account ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Request for unknown account: {}", request->start.to_account ()); current = request->end; } @@ -384,7 +384,7 @@ void nano::bulk_pull_server::set_current_end () auto account (node->ledger.account (transaction, request->end)); if (account != request->start.as_account ()) { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Request for block that is not on account chain: {} not on {}", request->end.to_string (), request->start.to_account ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Request for block that is not on account chain: {} not on {}", request->end.to_string (), request->start.to_account ()); current = request->end; } @@ -520,7 +520,7 @@ void nano::bulk_pull_server::sent_action (boost::system::error_code const & ec, } else { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send block: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send block: {}", ec.message ()); } } @@ -534,7 +534,7 @@ void nano::bulk_pull_server::send_finished () nano::shared_const_buffer send_buffer (static_cast (nano::block_type::not_a_block)); auto this_l (shared_from_this ()); - node->nlogger.debug (nano::log::type::bulk_pull_server, "Bulk sending finished"); + node->logger.debug (nano::log::type::bulk_pull_server, "Bulk sending finished"); connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->no_block_sent (ec, size_a); @@ -555,7 +555,7 @@ void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec } else { - node->nlogger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send not-a-block: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_server, "Unable to bulk send not-a-block: {}", ec.message ()); } } @@ -607,7 +607,7 @@ void nano::bulk_pull_account_server::set_params () } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Invalid bulk_pull_account flags supplied: {}", static_cast (request->flags)); + node->logger.debug (nano::log::type::bulk_pull_account_server, "Invalid bulk_pull_account flags supplied: {}", static_cast (request->flags)); invalid_request = true; return; @@ -709,7 +709,7 @@ void nano::bulk_pull_account_server::send_next_block () /* * Otherwise, finalize the connection */ - node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Done sending blocks"); + node->logger.debug (nano::log::type::bulk_pull_account_server, "Done sending blocks"); send_finished (); } @@ -814,7 +814,7 @@ void nano::bulk_pull_account_server::sent_action (boost::system::error_code cons } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Unable to bulk send block: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_account_server, "Unable to bulk send block: {}", ec.message ()); } } @@ -851,7 +851,7 @@ void nano::bulk_pull_account_server::send_finished () } } - node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Bulk sending for an account finished"); + node->logger.debug (nano::log::type::bulk_pull_account_server, "Bulk sending for an account finished"); auto this_l (shared_from_this ()); connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { @@ -888,7 +888,7 @@ void nano::bulk_pull_account_server::complete (boost::system::error_code const & } else { - node->nlogger.debug (nano::log::type::bulk_pull_account_server, "Unable to pending-as-zero: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_pull_account_server, "Unable to pending-as-zero: {}", ec.message ()); } } diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index 8dfeeeeb9a..5ff069ba12 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -38,7 +38,7 @@ void nano::bulk_push_client::start () } else { - node->nlogger.debug (nano::log::type::bulk_push_client, "Unable to send bulk push request: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_push_client, "Unable to send bulk push request: {}", ec.message ()); } }, nano::transport::buffer_drop_policy::no_limiter_drop); @@ -68,7 +68,7 @@ void nano::bulk_push_client::push () } else { - node->nlogger.debug (nano::log::type::bulk_push_client, "Bulk pushing range: [{}:{}]", current_target.first.to_string (), current_target.second.to_string ()); + node->logger.debug (nano::log::type::bulk_push_client, "Bulk pushing range: [{}:{}]", current_target.first.to_string (), current_target.second.to_string ()); } } } @@ -118,7 +118,7 @@ void nano::bulk_push_client::push_block (nano::block const & block_a) } else { - node->nlogger.debug (nano::log::type::bulk_push_client, "Error sending block during bulk push: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_push_client, "Error sending block during bulk push: {}", ec.message ()); } }); } @@ -162,7 +162,7 @@ void nano::bulk_push_server::receive () } if (node->bootstrap_initiator.in_progress ()) { - node->nlogger.debug (nano::log::type::bulk_push_server, "Aborting bulk push because a bootstrap attempt is in progress"); + node->logger.debug (nano::log::type::bulk_push_server, "Aborting bulk push because a bootstrap attempt is in progress"); } else { @@ -179,7 +179,7 @@ void nano::bulk_push_server::receive () } else { - node->nlogger.debug (nano::log::type::bulk_push_server, "Error receiving block type: {}", ec.message ()); + node->logger.debug (nano::log::type::bulk_push_server, "Error receiving block type: {}", ec.message ()); } }); } @@ -243,7 +243,7 @@ void nano::bulk_push_server::received_type () } default: { - node->nlogger.debug (nano::log::type::bulk_push_server, "Unknown type received as block type"); + node->logger.debug (nano::log::type::bulk_push_server, "Unknown type received as block type"); break; } } @@ -264,7 +264,7 @@ void nano::bulk_push_server::received_block (boost::system::error_code const & e { if (node->network_params.work.validate_entry (*block)) { - node->nlogger.debug (nano::log::type::bulk_push_server, "Insufficient work for bulk push block: {}", block->hash ().to_string ()); + node->logger.debug (nano::log::type::bulk_push_server, "Insufficient work for bulk push block: {}", block->hash ().to_string ()); node->stats.inc (nano::stat::type::error, nano::stat::detail::insufficient_work); return; } @@ -273,7 +273,7 @@ void nano::bulk_push_server::received_block (boost::system::error_code const & e } else { - node->nlogger.debug (nano::log::type::bulk_push_server, "Error deserializing block received from pull request"); + node->logger.debug (nano::log::type::bulk_push_server, "Error deserializing block received from pull request"); } } } diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index 8e2457c95f..ccb47c06a6 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -91,7 +91,7 @@ std::shared_ptr nano::bootstrap_connections::connection } if (result == nullptr && connections_count == 0 && new_connections_empty && attempt_a != nullptr) { - node.nlogger.debug (nano::log::type::bootstrap, "Bootstrap attempt stopped because there are no peers"); + node.logger.debug (nano::log::type::bootstrap, "Bootstrap attempt stopped because there are no peers"); lock.unlock (); attempt_a->stop (); @@ -158,7 +158,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) { if (!ec) { - this_l->node.nlogger.debug (nano::log::type::bootstrap, "Connection established to: {}", nano::util::to_str (endpoint_a)); + this_l->node.logger.debug (nano::log::type::bootstrap, "Connection established to: {}", nano::util::to_str (endpoint_a)); auto client (std::make_shared (this_l->node.shared (), std::make_shared (*this_l->node.shared (), socket), socket)); this_l->pool_connection (client, true, push_front); @@ -168,7 +168,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end switch (ec.value ()) { default: - this_l->node.nlogger.debug (nano::log::type::bootstrap, "Error initiating bootstrap connection to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + this_l->node.logger.debug (nano::log::type::bootstrap, "Error initiating bootstrap connection to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); break; case boost::system::errc::connection_refused: case boost::system::errc::operation_canceled: @@ -232,7 +232,7 @@ void nano::bootstrap_connections::populate_connections (bool repeat) // This is ~1.5kilobits/sec. if (elapsed_sec > nano::bootstrap_limits::bootstrap_minimum_termination_time_sec && blocks_per_sec < nano::bootstrap_limits::bootstrap_minimum_blocks_per_sec) { - node.nlogger.debug (nano::log::type::bootstrap, "Stopping slow peer {} (elapsed sec {} > {} and {} blocks per second < {})", + node.logger.debug (nano::log::type::bootstrap, "Stopping slow peer {} (elapsed sec {} > {} and {} blocks per second < {})", client->channel->to_string (), elapsed_sec, nano::bootstrap_limits::bootstrap_minimum_termination_time_sec, @@ -257,13 +257,13 @@ void nano::bootstrap_connections::populate_connections (bool repeat) // 4 -> 1, 8 -> 2, 16 -> 4, arbitrary, but seems to work well. auto drop = (int)roundf (sqrtf ((float)target - 2.0f)); - node.nlogger.debug (nano::log::type::bootstrap, "Dropping {} bulk pull peers, target connections {}", drop, target); + node.logger.debug (nano::log::type::bootstrap, "Dropping {} bulk pull peers, target connections {}", drop, target); for (int i = 0; i < drop; i++) { auto client = sorted_connections.top (); - node.nlogger.debug (nano::log::type::bootstrap, "Dropping peer with block rate {} and block count {} ({})", + node.logger.debug (nano::log::type::bootstrap, "Dropping peer with block rate {} and block count {} ({})", client->block_rate.load (), client->block_count.load (), client->channel->to_string ()); @@ -273,7 +273,7 @@ void nano::bootstrap_connections::populate_connections (bool repeat) } } - node.nlogger.debug (nano::log::type::bootstrap, "Bulk pull connections: {}, rate: {} blocks/sec, bootstrap attempts {}, remaining pulls: {}", + node.logger.debug (nano::log::type::bootstrap, "Bulk pull connections: {}, rate: {} blocks/sec, bootstrap attempts {}, remaining pulls: {}", connections_count.load (), (int)rate_sum, attempts_count, @@ -420,7 +420,7 @@ void nano::bootstrap_connections::requeue_pull (nano::pull_info const & pull_a, else { node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in); - node.nlogger.debug (nano::log::type::bootstrap, "Failed to pull account {} or head block {} down to {} after {} attempts and {} blocks processed", + node.logger.debug (nano::log::type::bootstrap, "Failed to pull account {} or head block {} down to {} after {} attempts and {} blocks processed", pull.account_or_head.to_account (), pull.account_or_head.to_string (), pull.end.to_string (), diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index b438c8a22d..7a9d580361 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -42,7 +42,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint } else { - node->nlogger.debug (nano::log::type::frontier_req_client, "Error while sending bootstrap request: {}", ec.message ()); + node->logger.debug (nano::log::type::frontier_req_client, "Error while sending bootstrap request: {}", ec.message ()); } }, nano::transport::buffer_drop_policy::no_limiter_drop); @@ -73,7 +73,7 @@ void nano::frontier_req_client::receive_frontier () } else { - node->nlogger.debug (nano::log::type::frontier_req_client, "Invalid size: expected {}, got {}", nano::frontier_req_client::size_frontier, size_a); + node->logger.debug (nano::log::type::frontier_req_client, "Invalid size: expected {}, got {}", nano::frontier_req_client::size_frontier, size_a); } }); } @@ -131,7 +131,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con double age_factor = (frontiers_age == std::numeric_limits::max ()) ? 1.0 : 1.5; // Allow slower frontiers receive for requests with age if (elapsed_sec > nano::bootstrap_limits::bootstrap_connection_warmup_time_sec && blocks_per_sec * age_factor < nano::bootstrap_limits::bootstrap_minimum_frontier_blocks_per_sec) { - node->nlogger.debug (nano::log::type::frontier_req_client, "Aborting frontier req because it was too slow: {} frontiers per second, last {}", blocks_per_sec, account.to_account ()); + node->logger.debug (nano::log::type::frontier_req_client, "Aborting frontier req because it was too slow: {} frontiers per second, last {}", blocks_per_sec, account.to_account ()); promise.set_value (true); return; @@ -139,7 +139,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con if (attempt->should_log ()) { - node->nlogger.debug (nano::log::type::frontier_req_client, "Received {} frontiers from {}", count, connection->channel->to_string ()); + node->logger.debug (nano::log::type::frontier_req_client, "Received {} frontiers from {}", count, connection->channel->to_string ()); } if (!account.is_zero () && count <= count_limit) @@ -201,7 +201,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con // Prevent new frontier_req requests attempt->set_start_account (std::numeric_limits::max ()); - node->nlogger.debug (nano::log::type::frontier_req_client, "Bulk push cost: {}", bulk_push_cost); + node->logger.debug (nano::log::type::frontier_req_client, "Bulk push cost: {}", bulk_push_cost); } else { @@ -220,7 +220,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con } else { - node->nlogger.debug (nano::log::type::frontier_req_client, "Error while receiving frontier: {}", ec.message ()); + node->logger.debug (nano::log::type::frontier_req_client, "Error while receiving frontier: {}", ec.message ()); } } @@ -311,7 +311,7 @@ void nano::frontier_req_server::send_finished () write (stream, zero.bytes); } - node->nlogger.debug (nano::log::type::frontier_req_server, "Frontier sending finished"); + node->logger.debug (nano::log::type::frontier_req_server, "Frontier sending finished"); auto this_l (shared_from_this ()); connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { @@ -332,7 +332,7 @@ void nano::frontier_req_server::no_block_sent (boost::system::error_code const & } else { - node->nlogger.debug (nano::log::type::frontier_req_server, "Error sending frontier finish: {}", ec.message ()); + node->logger.debug (nano::log::type::frontier_req_server, "Error sending frontier finish: {}", ec.message ()); } } @@ -353,7 +353,7 @@ void nano::frontier_req_server::sent_action (boost::system::error_code const & e } else { - node->nlogger.debug (nano::log::type::frontier_req_server, "Error sending frontier pair: {}", ec.message ()); + node->logger.debug (nano::log::type::frontier_req_server, "Error sending frontier pair: {}", ec.message ()); } } diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 35b0153120..0d3dbc9408 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -250,11 +250,11 @@ void nano::bootstrap_attempt_lazy::run () } if (!stopped) { - node->nlogger.debug (nano::log::type::bootstrap_lazy, "Completed lazy pulls"); + node->logger.debug (nano::log::type::bootstrap_lazy, "Completed lazy pulls"); } if (lazy_has_expired ()) { - node->nlogger.debug (nano::log::type::bootstrap_lazy, "Lazy bootstrap attempt ID {} expired", id); + node->logger.debug (nano::log::type::bootstrap_lazy, "Lazy bootstrap attempt ID {} expired", id); } lock.unlock (); stop (); @@ -613,7 +613,7 @@ void nano::bootstrap_attempt_wallet::run () } if (!stopped) { - node->nlogger.info (nano::log::type::bootstrap_lazy, "Completed wallet lazy pulls"); + node->logger.info (nano::log::type::bootstrap_lazy, "Completed wallet lazy pulls"); } lock.unlock (); stop (); diff --git a/nano/node/bootstrap/bootstrap_legacy.cpp b/nano/node/bootstrap/bootstrap_legacy.cpp index 2a1c670979..25605c91b5 100644 --- a/nano/node/bootstrap/bootstrap_legacy.cpp +++ b/nano/node/bootstrap/bootstrap_legacy.cpp @@ -180,7 +180,7 @@ bool nano::bootstrap_attempt_legacy::request_frontier (nano::unique_locknlogger.debug (nano::log::type::bootstrap_legacy, "Completed frontier request, {} out of sync accounts according to {}", account_count.load (), connection_l->channel->to_string ()); + node->logger.debug (nano::log::type::bootstrap_legacy, "Completed frontier request, {} out of sync accounts according to {}", account_count.load (), connection_l->channel->to_string ()); } else { @@ -230,7 +230,7 @@ void nano::bootstrap_attempt_legacy::run () if (start_account.number () != std::numeric_limits::max ()) { - node->nlogger.debug(nano::log::type::bootstrap_legacy, "Requesting new frontiers after: {}", start_account.to_account ()); + node->logger.debug(nano::log::type::bootstrap_legacy, "Requesting new frontiers after: {}", start_account.to_account ()); // Requesting new frontiers run_start (lock); @@ -238,7 +238,7 @@ void nano::bootstrap_attempt_legacy::run () } if (!stopped) { - node->nlogger.debug(nano::log::type::bootstrap_legacy, "Completed legacy pulls"); + node->logger.debug(nano::log::type::bootstrap_legacy, "Completed legacy pulls"); if (!node->flags.disable_bootstrap_bulk_push_client) { diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 4bb19c8747..ce9369fc14 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -255,7 +255,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (vm.count ("initialize")) { // TODO: --config flag overrides are not taken into account here - nano::nlogger::initialize (nano::log_config::daemon_default (), data_path); + nano::logger::initialize (nano::log_config::daemon_default (), data_path); auto node_flags = nano::inactive_node_flag_defaults (); node_flags.read_only = false; diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 8bcb25756a..9136dc7c5d 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -10,11 +10,11 @@ #include -nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::nlogger & nlogger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : +nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logger & logger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a), - nlogger (nlogger_a), + logger (logger_a), stopped (stopped_a), batch_write_size (batch_write_size_a), notify_observers_callback (notify_observers_callback_a), @@ -98,7 +98,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or } else { - nlogger.critical (nano::log::type::conf_processor_bounded, "Ledger mismatch trying to set confirmation height for block {} (bounded processor)", current.to_string ()); + logger.critical (nano::log::type::conf_processor_bounded, "Ledger mismatch trying to set confirmation height for block {} (bounded processor)", current.to_string ()); release_assert (block); } @@ -429,7 +429,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope { if (!block) { - nlogger.critical (nano::log::type::conf_processor_bounded, "Failed to write confirmation height for block {} (bounded processor)", new_cemented_frontier.to_string ()); + logger.critical (nano::log::type::conf_processor_bounded, "Failed to write confirmation height for block {} (bounded processor)", new_cemented_frontier.to_string ()); // Undo any blocks about to be cemented from this account for this pending write. cemented_blocks.erase (cemented_blocks.end () - num_blocks_iterated, cemented_blocks.end ()); diff --git a/nano/node/confirmation_height_bounded.hpp b/nano/node/confirmation_height_bounded.hpp index ee453769cd..a5052b1452 100644 --- a/nano/node/confirmation_height_bounded.hpp +++ b/nano/node/confirmation_height_bounded.hpp @@ -18,7 +18,7 @@ class write_guard; class confirmation_height_bounded final { public: - confirmation_height_bounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::nlogger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + confirmation_height_bounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::logger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); bool pending_empty () const; void clear_process_vars (); @@ -121,7 +121,7 @@ class confirmation_height_bounded final nano::ledger & ledger; nano::write_database_queue & write_database_queue; std::chrono::milliseconds batch_separate_pending_min_time; - nano::nlogger & nlogger; + nano::logger & logger; std::atomic & stopped; uint64_t & batch_write_size; std::function> const &)> notify_observers_callback; diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index a3c9b325c7..4b9d9d82a6 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -8,16 +8,16 @@ #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::nlogger & nlogger_a, boost::latch & latch, confirmation_height_mode mode_a) : +nano::confirmation_height_processor::confirmation_height_processor (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logger & logger_a, boost::latch & latch, confirmation_height_mode mode_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), unbounded_processor ( - ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, nlogger_a, stopped, batch_write_size, + ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logger_a, stopped, batch_write_size, /* cemented_callback */ [this] (auto & cemented_blocks) { this->notify_cemented (cemented_blocks); }, /* already cemented_callback */ [this] (auto const & block_hash_a) { this->notify_already_cemented (block_hash_a); }, /* awaiting_processing_size_query */ [this] () { return this->awaiting_processing_size (); }), bounded_processor ( - ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, nlogger_a, stopped, batch_write_size, + ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logger_a, stopped, batch_write_size, /* cemented_callback */ [this] (auto & cemented_blocks) { this->notify_cemented (cemented_blocks); }, /* already cemented_callback */ [this] (auto const & block_hash_a) { this->notify_already_cemented (block_hash_a); }, /* awaiting_processing_size_query */ [this] () { return this->awaiting_processing_size (); }), diff --git a/nano/node/confirmation_height_processor.hpp b/nano/node/confirmation_height_processor.hpp index 1767f82106..d31267833f 100644 --- a/nano/node/confirmation_height_processor.hpp +++ b/nano/node/confirmation_height_processor.hpp @@ -30,7 +30,7 @@ class write_database_queue; class confirmation_height_processor final { public: - confirmation_height_processor (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds, nano::nlogger &, boost::latch & initialized_latch, confirmation_height_mode = confirmation_height_mode::automatic); + confirmation_height_processor (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds, nano::logger &, boost::latch & initialized_latch, confirmation_height_mode = confirmation_height_mode::automatic); ~confirmation_height_processor (); void pause (); diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 4b7f9fffe5..8f50f39dcb 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -10,11 +10,11 @@ #include -nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::nlogger & nlogger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : +nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logger & logger_a, std::atomic & stopped_a, uint64_t & batch_write_size_a, std::function> const &)> const & notify_observers_callback_a, std::function const & notify_block_already_cemented_observers_callback_a, std::function const & awaiting_processing_size_callback_a) : ledger (ledger_a), write_database_queue (write_database_queue_a), batch_separate_pending_min_time (batch_separate_pending_min_time_a), - nlogger (nlogger_a), + logger (logger_a), stopped (stopped_a), batch_write_size (batch_write_size_a), notify_observers_callback (notify_observers_callback_a), @@ -74,7 +74,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr } if (!block) { - nlogger.critical (nano::log::type::conf_processor_unbounded, "Ledger mismatch trying to set confirmation height for block {} (unbounded processor)", current.to_string ()); + logger.critical (nano::log::type::conf_processor_unbounded, "Ledger mismatch trying to set confirmation height for block {} (unbounded processor)", current.to_string ()); } release_assert (block); @@ -390,7 +390,7 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco } else { - nlogger.critical (nano::log::type::conf_processor_unbounded, "Failed to write confirmation height for block {} (unbounded processor)", pending.hash.to_string ()); + logger.critical (nano::log::type::conf_processor_unbounded, "Failed to write confirmation height for block {} (unbounded processor)", pending.hash.to_string ()); error = true; break; diff --git a/nano/node/confirmation_height_unbounded.hpp b/nano/node/confirmation_height_unbounded.hpp index 2264d6fa06..ea3e7e52a1 100644 --- a/nano/node/confirmation_height_unbounded.hpp +++ b/nano/node/confirmation_height_unbounded.hpp @@ -19,7 +19,7 @@ class write_guard; class confirmation_height_unbounded final { public: - confirmation_height_unbounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::nlogger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); + confirmation_height_unbounded (nano::ledger &, nano::write_database_queue &, std::chrono::milliseconds batch_separate_pending_min_time, nano::logger &, std::atomic & stopped, uint64_t & batch_write_size, std::function> const &)> const & cemented_callback, std::function const & already_cemented_callback, std::function const & awaiting_processing_size_query); bool pending_empty () const; void clear_process_vars (); @@ -98,7 +98,7 @@ class confirmation_height_unbounded final nano::ledger & ledger; nano::write_database_queue & write_database_queue; std::chrono::milliseconds batch_separate_pending_min_time; - nano::nlogger & nlogger; + nano::logger & logger; std::atomic & stopped; uint64_t & batch_write_size; diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index d7031f5f18..7d1849fb9b 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -94,7 +94,7 @@ void nano::distributed_work::start () } else { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Error resolving work peer: {}:{} ({})", peer.first, peer.second, ec.message ()); + this_l->node.logger.error (nano::log::type::distributed_work, "Error resolving work peer: {}:{} ({})", peer.first, peer.second, ec.message ()); this_l->failure (); } @@ -167,7 +167,7 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec) { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Work peer responded with an error {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Work peer responded with an error {}:{} ({})", nano::util::to_str (connection->endpoint.address ()), connection->endpoint.port (), ec.message ()); @@ -185,7 +185,7 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to write to work peer {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Unable to write to work peer {}:{} ({})", nano::util::to_str (connection->endpoint.address ()), connection->endpoint.port (), ec.message ()); @@ -197,7 +197,7 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) } else if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to connect to work peer {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Unable to connect to work peer {}:{} ({})", nano::util::to_str (connection->endpoint.address ()), connection->endpoint.port (), ec.message ()); @@ -232,7 +232,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a) [this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, std::size_t bytes_transferred) { if (ec && ec != boost::system::errc::operation_canceled) { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Unable to send work cancel to work peer {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Unable to send work cancel to work peer {}:{} ({})", nano::util::to_str (cancelling_l->endpoint.address ()), cancelling_l->endpoint.port (), ec.message ()); @@ -263,7 +263,7 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp } else { - node.nlogger.error (nano::log::type::distributed_work, "Incorrect work response from {}:{} for root {} with diffuculty {}: {}", + node.logger.error (nano::log::type::distributed_work, "Incorrect work response from {}:{} for root {} with diffuculty {}: {}", nano::util::to_str (endpoint_a.address ()), endpoint_a.port (), request.root.to_string (), @@ -273,7 +273,7 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp } else { - node.nlogger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't a number: {}", + node.logger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't a number: {}", nano::util::to_str (endpoint_a.address ()), endpoint_a.port (), work_text); @@ -281,7 +281,7 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp } catch (...) { - node.nlogger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't parsable: {}", + node.logger.error (nano::log::type::distributed_work, "Work response from {}:{} wasn't parsable: {}", nano::util::to_str (endpoint_a.address ()), endpoint_a.port (), body_a); @@ -317,7 +317,7 @@ void nano::distributed_work::stop_once (bool const local_stop_a) connection_l->socket.close (ec); if (ec) { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Error closing socket with work peer: {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Error closing socket with work peer: {}:{} ({})", nano::util::to_str (connection_l->endpoint.address ()), connection_l->endpoint.port (), ec.message ()); @@ -325,7 +325,7 @@ void nano::distributed_work::stop_once (bool const local_stop_a) } else { - this_l->node.nlogger.error (nano::log::type::distributed_work, "Error cancelling operation with work peer: {}:{} ({})", + this_l->node.logger.error (nano::log::type::distributed_work, "Error cancelling operation with work peer: {}:{} ({})", nano::util::to_str (connection_l->endpoint.address ()), connection_l->endpoint.port (), ec.message ()); @@ -344,7 +344,7 @@ void nano::distributed_work::set_once (uint64_t const work_a, std::string const { elapsed.stop (); - node.nlogger.info (nano::log::type::distributed_work, "Work generation for {}, with a threshold difficulty of {} (multiplier {}x) complete: {} ms", + node.logger.info (nano::log::type::distributed_work, "Work generation for {}, with a threshold difficulty of {} (multiplier {}x) complete: {} ms", request.root.to_string (), nano::to_string_hex (request.difficulty), nano::to_string (nano::difficulty::to_multiplier (request.difficulty, node.default_difficulty (request.version)), 2), @@ -366,7 +366,7 @@ void nano::distributed_work::cancel () { elapsed.stop (); - node.nlogger.info (nano::log::type::distributed_work, "Work generation for {} was cancelled after {} ms", + node.logger.info (nano::log::type::distributed_work, "Work generation for {} was cancelled after {} ms", request.root.to_string (), elapsed.value ().count ()); @@ -394,7 +394,7 @@ void nano::distributed_work::handle_failure () node.unresponsive_work_peers = true; if (!local_generation_started && !finished.exchange (true)) { - node.nlogger.info (nano::log::type::distributed_work, "Work peer(s) failed to generate work for root {}, retrying... (backoff: {}s)", + node.logger.info (nano::log::type::distributed_work, "Work peer(s) failed to generate work for root {}, retrying... (backoff: {}s)", request.root.to_string (), backoff.count ()); diff --git a/nano/node/epoch_upgrader.cpp b/nano/node/epoch_upgrader.cpp index c9443cd367..df30195032 100644 --- a/nano/node/epoch_upgrader.cpp +++ b/nano/node/epoch_upgrader.cpp @@ -2,12 +2,12 @@ #include #include -nano::epoch_upgrader::epoch_upgrader (nano::node & node_a, nano::ledger & ledger_a, nano::store::component & store_a, nano::network_params & network_params_a, nano::nlogger & nlogger_a) : +nano::epoch_upgrader::epoch_upgrader (nano::node & node_a, nano::ledger & ledger_a, nano::store::component & store_a, nano::network_params & network_params_a, nano::logger & logger_a) : node{ node_a }, ledger{ ledger_a }, store{ store_a }, network_params{ network_params_a }, - nlogger{ nlogger_a } + logger{ logger_a } { } @@ -60,7 +60,7 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc { bool fork (result == nano::process_result::fork); - nlogger.error (nano::log::type::epoch_upgrader, "Failed to upgrade account {} (valid signature: {}, valid work: {}, fork: {})", + logger.error (nano::log::type::epoch_upgrader, "Failed to upgrade account {} (valid signature: {}, valid work: {}, fork: {})", account_a.to_account (), valid_signature, valid_work, @@ -186,7 +186,7 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc if (!accounts_list.empty ()) { - nlogger.info (nano::log::type::epoch_upgrader, "{} accounts were upgraded to new epoch, {} remain...", + logger.info (nano::log::type::epoch_upgrader, "{} accounts were upgraded to new epoch, {} remain...", total_upgraded_accounts, accounts_list.size () - upgraded_accounts); @@ -194,7 +194,7 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc } else { - nlogger.info (nano::log::type::epoch_upgrader, "{} total accounts were upgraded to new epoch", total_upgraded_accounts); + logger.info (nano::log::type::epoch_upgrader, "{} total accounts were upgraded to new epoch", total_upgraded_accounts); finished_accounts = true; } @@ -293,11 +293,11 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc // Repeat if some pending accounts were upgraded if (upgraded_pending != 0) { - nlogger.info (nano::log::type::epoch_upgrader, "{} unopened accounts with pending blocks were upgraded to new epoch...", total_upgraded_pending); + logger.info (nano::log::type::epoch_upgrader, "{} unopened accounts with pending blocks were upgraded to new epoch...", total_upgraded_pending); } else { - nlogger.info (nano::log::type::epoch_upgrader, "{} total unopened accounts with pending blocks were upgraded to new epoch", total_upgraded_pending); + logger.info (nano::log::type::epoch_upgrader, "{} total unopened accounts with pending blocks were upgraded to new epoch", total_upgraded_pending); finished_pending = true; } @@ -306,5 +306,5 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc finished_upgrade = (total_upgraded_accounts == 0) && (total_upgraded_pending == 0); } - nlogger.info (nano::log::type::epoch_upgrader, "Epoch upgrade is completed"); + logger.info (nano::log::type::epoch_upgrader, "Epoch upgrade is completed"); } diff --git a/nano/node/epoch_upgrader.hpp b/nano/node/epoch_upgrader.hpp index 3f85b9985b..d9bccad98e 100644 --- a/nano/node/epoch_upgrader.hpp +++ b/nano/node/epoch_upgrader.hpp @@ -20,7 +20,7 @@ class network_params; class epoch_upgrader final { public: - epoch_upgrader (nano::node &, nano::ledger &, nano::store::component &, nano::network_params &, nano::nlogger &); + epoch_upgrader (nano::node &, nano::ledger &, nano::store::component &, nano::network_params &, nano::logger &); bool start (nano::raw_key const & prv, nano::epoch epoch, uint64_t count_limit, uint64_t threads); void stop (); @@ -30,7 +30,7 @@ class epoch_upgrader final nano::ledger & ledger; nano::store::component & store; nano::network_params & network_params; - nano::nlogger & nlogger; + nano::logger & logger; private: void upgrade_impl (nano::raw_key const & prv, nano::epoch epoch, uint64_t count_limit, uint64_t threads); diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp index 384f1888b6..1ef81dd598 100644 --- a/nano/node/gap_cache.cpp +++ b/nano/node/gap_cache.cpp @@ -100,7 +100,7 @@ void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a) { if (!node_l->bootstrap_initiator.in_progress ()) { - node_l->nlogger.debug (nano::log::type::gap_cache, "Block {} has enough votes to warrant lazy bootstrapping it", hash_a.to_string ()); + node_l->logger.debug (nano::log::type::gap_cache, "Block {} has enough votes to warrant lazy bootstrapping it", hash_a.to_string ()); } if (!node_l->flags.disable_lazy_bootstrap) { diff --git a/nano/node/ipc/ipc_broker.cpp b/nano/node/ipc/ipc_broker.cpp index cf625ee791..15ba718cca 100644 --- a/nano/node/ipc/ipc_broker.cpp +++ b/nano/node/ipc/ipc_broker.cpp @@ -65,17 +65,17 @@ void nano::ipc::broker::start () } catch (nano::error const & err) { - this_l->node.nlogger.error (nano::log::type::ipc, "Could not broadcast message: {}", err.get_message ()); + this_l->node.logger.error (nano::log::type::ipc, "Could not broadcast message: {}", err.get_message ()); } }); } template -void subscribe_or_unsubscribe (nano::nlogger & nlogger, COLL & subscriber_collection, std::weak_ptr const & subscriber_a, TOPIC_TYPE topic_a) +void subscribe_or_unsubscribe (nano::logger & logger, COLL & subscriber_collection, std::weak_ptr const & subscriber_a, TOPIC_TYPE topic_a) { // Evict subscribers from dead sessions. Also remove current subscriber if unsubscribing. subscriber_collection.erase (std::remove_if (subscriber_collection.begin (), subscriber_collection.end (), - [&nlogger = nlogger, topic_a, subscriber_a] (auto & sub) { + [&logger = logger, topic_a, subscriber_a] (auto & sub) { bool remove = false; auto subscriber_l = sub.subscriber.lock (); if (subscriber_l) @@ -85,7 +85,7 @@ void subscribe_or_unsubscribe (nano::nlogger & nlogger, COLL & subscriber_collec remove = topic_a->unsubscribe && subscriber_l->get_id () == calling_subscriber_l->get_id (); if (remove) { - nlogger.info (nano::log::type::ipc, "Subscriber ubsubscribed #{}", calling_subscriber_l->get_id ()); + logger.info (nano::log::type::ipc, "Subscriber ubsubscribed #{}", calling_subscriber_l->get_id ()); } } } @@ -106,7 +106,7 @@ void subscribe_or_unsubscribe (nano::nlogger & nlogger, COLL & subscriber_collec void nano::ipc::broker::subscribe (std::weak_ptr const & subscriber_a, std::shared_ptr const & confirmation_a) { auto subscribers = confirmation_subscribers.lock (); - subscribe_or_unsubscribe (node.nlogger, subscribers.get (), subscriber_a, confirmation_a); + subscribe_or_unsubscribe (node.logger, subscribers.get (), subscriber_a, confirmation_a); } void nano::ipc::broker::broadcast (std::shared_ptr const & confirmation_a) @@ -257,5 +257,5 @@ void nano::ipc::broker::service_stop (std::string const & service_name_a) void nano::ipc::broker::subscribe (std::weak_ptr const & subscriber_a, std::shared_ptr const & service_stop_a) { auto subscribers = service_stop_subscribers.lock (); - subscribe_or_unsubscribe (node.nlogger, subscribers.get (), subscriber_a, service_stop_a); + subscribe_or_unsubscribe (node.logger, subscribers.get (), subscriber_a, service_stop_a); } diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index b629fc72e2..ab5b39ef02 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -37,7 +37,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f server (server_a), node (server_a.node), session_id (server_a.id_dispenser.fetch_add (1)), io_ctx (io_ctx_a), strand (io_ctx_a.get_executor ()), socket (io_ctx_a), config_transport (config_transport_a) { - node.nlogger.debug (nano::log::type::ipc, "Creating session with id: ", session_id.load ()); + node.logger.debug (nano::log::type::ipc, "Creating session with id: ", session_id.load ()); } ~session () @@ -229,7 +229,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f this_l->timer_cancel (); if (ec == boost::asio::error::broken_pipe || ec == boost::asio::error::connection_aborted || ec == boost::asio::error::connection_reset || ec == boost::asio::error::connection_refused) { - this_l->node.nlogger.error (nano::log::type::ipc, "Error reading: ", ec.message ()); + this_l->node.logger.error (nano::log::type::ipc, "Error reading: ", ec.message ()); } else if (bytes_transferred_a > 0) { @@ -253,7 +253,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f buffer->insert (buffer->end (), reinterpret_cast (&big), reinterpret_cast (&big) + sizeof (std::uint32_t)); buffer->insert (buffer->end (), body.begin (), body.end ()); - this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/RPC request {} completed in: {} {}", + this_l->node.logger.debug (nano::log::type::ipc, "IPC/RPC request {} completed in: {} {}", request_id_l, this_l->session_timer.stop ().count (), this_l->session_timer.unit ()); @@ -267,7 +267,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f } else { - this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: ", error_a.message ()); + this_l->node.logger.error (nano::log::type::ipc, "Write failed: ", error_a.message ()); } }); @@ -300,7 +300,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f this_l->active_encoding = static_cast (encoding); if (this_l->buffer[nano::ipc::preamble_offset::lead] != 'N' || this_l->buffer[nano::ipc::preamble_offset::reserved_1] != 0 || this_l->buffer[nano::ipc::preamble_offset::reserved_2] != 0) { - this_l->node.nlogger.error (nano::log::type::ipc, "Invalid preamble"); + this_l->node.logger.error (nano::log::type::ipc, "Invalid preamble"); } else if (encoding == static_cast (nano::ipc::payload_encoding::json_v1) || encoding == static_cast (nano::ipc::payload_encoding::json_v1_unsafe)) { @@ -334,7 +334,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f if (encoding == static_cast (nano::ipc::payload_encoding::flatbuffers_json)) { this_l->flatbuffers_handler->process_json (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr const & body) { - this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", + this_l->node.logger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", this_l->session_timer.stop ().count (), this_l->session_timer.unit ()); @@ -351,7 +351,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f } else { - this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); + this_l->node.logger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); } }); }); @@ -359,7 +359,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f else { this_l->flatbuffers_handler->process (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr const & fbb) { - this_l->node.nlogger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", + this_l->node.logger.debug (nano::log::type::ipc, "IPC/Flatbuffer request completed in: {} {}", this_l->session_timer.stop ().count (), this_l->session_timer.unit ()); @@ -376,7 +376,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f } else { - this_l->node.nlogger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); + this_l->node.logger.error (nano::log::type::ipc, "Write failed: {}", error_a.message ()); } }); }); @@ -386,7 +386,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f } else { - this_l->node.nlogger.error (nano::log::type::ipc, "Unsupported payload encoding"); + this_l->node.logger.error (nano::log::type::ipc, "Unsupported payload encoding"); } }); } @@ -511,7 +511,7 @@ class socket_transport : public nano::ipc::transport } else { - node->nlogger.error (nano::log::type::ipc, "Acceptor error: ", ec.message ()); + node->logger.error (nano::log::type::ipc, "Acceptor error: ", ec.message ()); } if (ec != boost::asio::error::operation_aborted && acceptor->is_open ()) @@ -520,7 +520,7 @@ class socket_transport : public nano::ipc::transport } else { - node->nlogger.info (nano::log::type::ipc, "Shutting down"); + node->logger.info (nano::log::type::ipc, "Shutting down"); } }); } @@ -613,7 +613,7 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co boost::asio::local::stream_protocol::endpoint ep{ node_a.config.ipc_config.transport_domain.path }; transports.push_back (std::make_shared (*this, ep, node_a.config.ipc_config.transport_domain, threads)); #else - node.nlogger.error (nano::log::type::ipc_server, "Domain sockets are not supported on this platform"); + node.logger.error (nano::log::type::ipc_server, "Domain sockets are not supported on this platform"); #endif } @@ -623,7 +623,7 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co transports.push_back (std::make_shared (*this, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v6 (), node_a.config.ipc_config.transport_tcp.port), node_a.config.ipc_config.transport_tcp, threads)); } - node.nlogger.debug (nano::log::type::ipc_server, "Server started"); + node.logger.debug (nano::log::type::ipc_server, "Server started"); if (!transports.empty ()) { @@ -632,13 +632,13 @@ nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config co } catch (std::runtime_error const & ex) { - node.nlogger.error (nano::log::type::ipc_server, "Error: {}", ex.what ()); + node.logger.error (nano::log::type::ipc_server, "Error: {}", ex.what ()); } } nano::ipc::ipc_server::~ipc_server () { - node.nlogger.debug (nano::log::type::ipc_server, "Server stopped"); + node.logger.debug (nano::log::type::ipc_server, "Server stopped"); } void nano::ipc::ipc_server::stop () @@ -678,7 +678,7 @@ nano::error nano::ipc::ipc_server::reload_access_config () nano::error access_config_error (nano::ipc::read_access_config_toml (node.application_path, access)); if (access_config_error) { - node.nlogger.error (nano::log::type::ipc_server, "Invalid access configuration file: {}", access_config_error.get_message ()); + node.logger.error (nano::log::type::ipc_server, "Invalid access configuration file: {}", access_config_error.get_message ()); } return access_config_error; } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3bd22bf980..58af00f1c5 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -2955,7 +2955,7 @@ void nano::json_handler::password_change () rpc_l->response_l.put ("changed", error ? "0" : "1"); if (!error) { - rpc_l->node.nlogger.warn (nano::log::type::rpc, "Wallet password changed"); + rpc_l->node.logger.warn (nano::log::type::rpc, "Wallet password changed"); } } } @@ -4774,7 +4774,7 @@ void nano::json_handler::wallet_lock () wallet->store.password.value_set (empty); response_l.put ("locked", "1"); - node.nlogger.warn (nano::log::type::rpc, "Wallet locked"); + node.logger.warn (nano::log::type::rpc, "Wallet locked"); } response_errors (); } diff --git a/nano/node/make_store.cpp b/nano/node/make_store.cpp index fda5c9ac20..c3c8c28105 100644 --- a/nano/node/make_store.cpp +++ b/nano/node/make_store.cpp @@ -2,7 +2,7 @@ #include #include -std::unique_ptr nano::make_store (nano::nlogger & logger, std::filesystem::path const & path, nano::ledger_constants & constants, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) +std::unique_ptr nano::make_store (nano::logger & logger, std::filesystem::path const & path, nano::ledger_constants & constants, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) { if (rocksdb_config.enable) { diff --git a/nano/node/make_store.hpp b/nano/node/make_store.hpp index b467c07ce8..5f5b5f9372 100644 --- a/nano/node/make_store.hpp +++ b/nano/node/make_store.hpp @@ -22,5 +22,5 @@ class component; namespace nano { -std::unique_ptr make_store (nano::nlogger &, std::filesystem::path const & path, nano::ledger_constants & constants, bool open_read_only = false, bool add_db_postfix = true, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); +std::unique_ptr make_store (nano::logger &, std::filesystem::path const & path, nano::ledger_constants & constants, bool open_read_only = false, bool add_db_postfix = true, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); } diff --git a/nano/node/network.cpp b/nano/node/network.cpp index ab81aa6b0a..d02026deac 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -38,22 +38,22 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : } catch (boost::system::error_code & ec) { - node.nlogger.critical (nano::log::type::network, "Error: {}", ec.message ()); + node.logger.critical (nano::log::type::network, "Error: {}", ec.message ()); release_assert (false); } catch (std::error_code & ec) { - node.nlogger.critical (nano::log::type::network, "Error: {}", ec.message ()); + node.logger.critical (nano::log::type::network, "Error: {}", ec.message ()); release_assert (false); } catch (std::runtime_error & err) { - node.nlogger.critical (nano::log::type::network, "Error: {}", err.what ()); + node.logger.critical (nano::log::type::network, "Error: {}", err.what ()); release_assert (false); } catch (...) { - node.nlogger.critical (nano::log::type::network, "Unknown error"); + node.logger.critical (nano::log::type::network, "Unknown error"); release_assert (false); } }); @@ -127,7 +127,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrget_endpoint ()), (query ? query->cookie.to_string () : ""), (respond_to ? respond_to->to_string () : ""), diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 07c6922c6c..52ab7f1afd 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -84,7 +84,7 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) } else { - node_l->nlogger.error (nano::log::type::node, "Error resolving address for keepalive: {}:{} ({})", address_a, port_a, ec.message ()); + node_l->logger.error (nano::log::type::node, "Error resolving address for keepalive: {}:{} ({})", address_a, port_a, ec.message ()); } }); } @@ -144,14 +144,14 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons node_initialized_latch (1), config (config_a), network_params{ config.network_params }, - nlogger{ make_logger_identifier (node_id) }, + logger{ make_logger_identifier (node_id) }, stats (config.stats_config), workers{ config.background_threads, nano::thread_role::name::worker }, bootstrap_workers{ config.bootstrap_serving_threads, nano::thread_role::name::bootstrap_worker }, flags (flags_a), work (work_a), distributed_work (*this), - store_impl (nano::make_store (nlogger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), + store_impl (nano::make_store (logger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), store (*store_impl), unchecked{ stats, flags.disable_block_processor_unchecked_deletion }, wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), @@ -177,13 +177,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons application_path (application_path_a), port_mapping (*this), rep_crawler (*this), - vote_processor (active, observers, stats, config, flags, nlogger, online_reps, rep_crawler, ledger, network_params), + vote_processor (active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params), warmed_up (0), block_processor (*this, write_database_queue), online_reps (ledger, config), history{ config.network_params.voting }, vote_uniquer{}, - confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, nlogger, node_initialized_latch, flags.confirmation_height_processor_mode), + confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, logger, node_initialized_latch, flags.confirmation_height_processor_mode), vote_cache{ config.vote_cache, stats }, generator{ config, ledger, wallets, vote_processor, history, network, stats, /* non-final */ false }, final_generator{ config, ledger, wallets, vote_processor, history, network, stats, /* final */ true }, @@ -194,8 +194,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons wallets (wallets_store.init_error (), *this), backlog{ nano::backlog_population_config (config), store, stats }, ascendboot{ config, block_processor, ledger, network, stats }, - websocket{ config.websocket_config, observers, wallets, ledger, io_ctx, nlogger }, - epoch_upgrader{ *this, ledger, store, network_params, nlogger }, + websocket{ config.websocket_config, observers, wallets, ledger, io_ctx, logger }, + epoch_upgrader{ *this, ledger, store, network_params, logger }, startup_time (std::chrono::steady_clock::now ()), node_seq (seq), block_broadcast{ network, block_arrival, !flags.disable_block_processor_republishing }, @@ -203,7 +203,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons gap_tracker{ gap_cache }, process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } { - nlogger.debug (nano::log::type::node, "Constructing node..."); + logger.debug (nano::log::type::node, "Constructing node..."); block_broadcast.connect (block_processor); block_publisher.connect (block_processor); @@ -293,7 +293,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons } else { - node_l->nlogger.error (nano::log::type::rpc_callbacks, "Error resolving callback: {}:{} ({})", address, port, ec.message ()); + node_l->logger.error (nano::log::type::rpc_callbacks, "Error resolving callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); @@ -342,21 +342,21 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons auto const network_label = network_params.network.get_current_network_as_string (); - nlogger.info (nano::log::type::node, "Node starting, version: {}", NANO_VERSION_STRING); - nlogger.info (nano::log::type::node, "Build information: {}", BUILD_INFO); - nlogger.info (nano::log::type::node, "Active network: {}", network_label); - nlogger.info (nano::log::type::node, "Database backend: {}", store.vendor_get ()); - nlogger.info (nano::log::type::node, "Data path: {}", application_path.string ()); - nlogger.info (nano::log::type::node, "Work pool threads: {} ({})", work.threads.size (), (work.opencl ? "OpenCL" : "CPU")); - nlogger.info (nano::log::type::node, "Work peers: {}", config.work_peers.size ()); - nlogger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ()); + logger.info (nano::log::type::node, "Node starting, version: {}", NANO_VERSION_STRING); + logger.info (nano::log::type::node, "Build information: {}", BUILD_INFO); + logger.info (nano::log::type::node, "Active network: {}", network_label); + logger.info (nano::log::type::node, "Database backend: {}", store.vendor_get ()); + logger.info (nano::log::type::node, "Data path: {}", application_path.string ()); + logger.info (nano::log::type::node, "Work pool threads: {} ({})", work.threads.size (), (work.opencl ? "OpenCL" : "CPU")); + logger.info (nano::log::type::node, "Work peers: {}", config.work_peers.size ()); + logger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ()); if (!work_generation_enabled ()) { - nlogger.info (nano::log::type::node, "Work generation is disabled"); + logger.info (nano::log::type::node, "Work generation is disabled"); } - nlogger.info (nano::log::type::node, "Outbound bandwidth limit: {} bytes/s, burst ratio: {}", + logger.info (nano::log::type::node, "Outbound bandwidth limit: {} bytes/s, burst ratio: {}", config.bandwidth_limit, config.bandwidth_limit_burst_ratio); @@ -376,11 +376,11 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons if (!ledger.block_or_pruned_exists (config.network_params.ledger.genesis->hash ())) { - nlogger.critical (nano::log::type::node, "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first."); + logger.critical (nano::log::type::node, "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first."); if (network_params.network.is_beta_network ()) { - nlogger.critical (nano::log::type::node, "Beta network may have reset, try clearing database files"); + logger.critical (nano::log::type::node, "Beta network may have reset, try clearing database files"); } std::exit (1); @@ -389,14 +389,14 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons if (config.enable_voting) { auto reps = wallets.reps (); - nlogger.info (nano::log::type::node, "Voting is enabled, more system resources will be used, local representatives: {}", reps.accounts.size ()); + logger.info (nano::log::type::node, "Voting is enabled, more system resources will be used, local representatives: {}", reps.accounts.size ()); for (auto const & account : reps.accounts) { - nlogger.info (nano::log::type::node, "Local representative: {}", account.to_account ()); + logger.info (nano::log::type::node, "Local representative: {}", account.to_account ()); } if (reps.accounts.size () > 1) { - nlogger.warn (nano::log::type::node, "Voting with more than one representative can limit performance"); + logger.warn (nano::log::type::node, "Voting with more than one representative can limit performance"); } } @@ -405,18 +405,18 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons auto const bootstrap_weights = get_bootstrap_weights (); ledger.bootstrap_weight_max_blocks = bootstrap_weights.first; - nlogger.info (nano::log::type::node, "Initial bootstrap height: {}", ledger.bootstrap_weight_max_blocks); - nlogger.info (nano::log::type::node, "Current ledger height: {}", ledger.cache.block_count.load ()); + logger.info (nano::log::type::node, "Initial bootstrap height: {}", ledger.bootstrap_weight_max_blocks); + logger.info (nano::log::type::node, "Current ledger height: {}", ledger.cache.block_count.load ()); // Use bootstrap weights if initial bootstrap is not completed const bool use_bootstrap_weight = ledger.cache.block_count < bootstrap_weights.first; if (use_bootstrap_weight) { - nlogger.info (nano::log::type::node, "Using predefined representative weights, since block count is less than bootstrap threshold"); + logger.info (nano::log::type::node, "Using predefined representative weights, since block count is less than bootstrap threshold"); ledger.bootstrap_weights = bootstrap_weights.second; - nlogger.info (nano::log::type::node, "************************************ Bootstrap weights ************************************"); + logger.info (nano::log::type::node, "************************************ Bootstrap weights ************************************"); // Sort the weights std::vector> sorted_weights (ledger.bootstrap_weights.begin (), ledger.bootstrap_weights.end ()); @@ -426,18 +426,18 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons for (auto const & rep : sorted_weights) { - nlogger.info (nano::log::type::node, "Using bootstrap rep weight: {} -> {}", + logger.info (nano::log::type::node, "Using bootstrap rep weight: {} -> {}", rep.first.to_account (), nano::uint128_union (rep.second).format_balance (Mxrb_ratio, 0, true)); } - nlogger.info (nano::log::type::node, "************************************ ================= ************************************"); + logger.info (nano::log::type::node, "************************************ ================= ************************************"); } // Drop unchecked blocks if initial bootstrap is completed if (!flags.disable_unchecked_drop && !use_bootstrap_weight && !flags.read_only) { - nlogger.info (nano::log::type::node, "Dropping unchecked blocks..."); + logger.info (nano::log::type::node, "Dropping unchecked blocks..."); unchecked.clear (); } } @@ -448,12 +448,12 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons { if (config.enable_voting && !flags.inactive_node) { - nlogger.critical (nano::log::type::node, "Incompatibility detected between config node.enable_voting and existing pruned blocks"); + logger.critical (nano::log::type::node, "Incompatibility detected between config node.enable_voting and existing pruned blocks"); std::exit (1); } else if (!flags.enable_pruning && !flags.inactive_node) { - nlogger.critical (nano::log::type::node, "To start node with existing pruned blocks use launch flag --enable_pruning"); + logger.critical (nano::log::type::node, "To start node with existing pruned blocks use launch flag --enable_pruning"); std::exit (1); } } @@ -463,7 +463,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons nano::node::~node () { - nlogger.debug (nano::log::type::node, "Destructing node..."); + logger.debug (nano::log::type::node, "Destructing node..."); stop (); } @@ -499,27 +499,27 @@ void nano::node::do_rpc_callback (boost::asio::ip::tcp::resolver::iterator i_a, } else { - node_l->nlogger.error (nano::log::type::rpc_callbacks, "Callback to {}:{} failed [status: {}]", address, port, nano::util::to_str (resp->result ())); + node_l->logger.error (nano::log::type::rpc_callbacks, "Callback to {}:{} failed [status: {}]", address, port, nano::util::to_str (resp->result ())); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } } else { - node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to complete callback: {}:{} ({})", address, port, ec.message ()); + node_l->logger.error (nano::log::type::rpc_callbacks, "Unable to complete callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); }; }); } else { - node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to send callback: {}:{} ({})", address, port, ec.message ()); + node_l->logger.error (nano::log::type::rpc_callbacks, "Unable to send callback: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); } else { - node_l->nlogger.error (nano::log::type::rpc_callbacks, "Unable to connect to callback address: {}:{} ({})", address, port, ec.message ()); + node_l->logger.error (nano::log::type::rpc_callbacks, "Unable to connect to callback address: {}:{} ({})", address, port, ec.message ()); node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); ++i_a; @@ -649,7 +649,7 @@ void nano::node::start () network.port = tcp_listener->endpoint ().port (); } - nlogger.info (nano::log::type::node, "Node peering port: {}", network.port.load ()); + logger.info (nano::log::type::node, "Node peering port: {}", network.port.load ()); } if (!flags.disable_backup) @@ -696,7 +696,7 @@ void nano::node::stop () return; } - nlogger.info (nano::log::type::node, "Node stopping..."); + logger.info (nano::log::type::node, "Node stopping..."); // Cancels ongoing work generation tasks, which may be blocking other threads // No tasks may wait for work generation in I/O threads, or termination signal capturing will be unable to call node::stop() @@ -805,7 +805,7 @@ void nano::node::long_inactivity_cleanup () { store.online_weight.clear (transaction); store.peer.clear (transaction); - nlogger.info (nano::log::type::node, "Removed records of peers and online weight after a long period of inactivity"); + logger.info (nano::log::type::node, "Removed records of peers and online weight after a long period of inactivity"); } } @@ -969,7 +969,7 @@ void nano::node::unchecked_cleanup () } if (!cleaning_list.empty ()) { - nlogger.info (nano::log::type::node, "Deleting {} old unchecked blocks", cleaning_list.size ()); + logger.info (nano::log::type::node, "Deleting {} old unchecked blocks", cleaning_list.size ()); } // Delete old unchecked keys in batches while (!cleaning_list.empty ()) @@ -1081,11 +1081,11 @@ void nano::node::ledger_pruning (uint64_t const batch_size_a, bool bootstrap_wei } pruned_count += transaction_write_count; - nlogger.debug (nano::log::type::prunning, "Pruned blocks: {}", pruned_count); + logger.debug (nano::log::type::prunning, "Pruned blocks: {}", pruned_count); } } - nlogger.debug (nano::log::type::prunning, "Total recently pruned block count: {}", pruned_count); + logger.debug (nano::log::type::prunning, "Total recently pruned block count: {}", pruned_count); } void nano::node::ongoing_ledger_pruning () @@ -1218,7 +1218,7 @@ void nano::node::add_initial_peers () { if (flags.disable_add_initial_peers) { - nlogger.warn (nano::log::type::node, "Not adding initial peers because `disable_add_initial_peers` flag is set"); + logger.warn (nano::log::type::node, "Not adding initial peers because `disable_add_initial_peers` flag is set"); return; } @@ -1298,12 +1298,12 @@ void nano::node::receive_confirmed (store::transaction const & block_transaction { if (!ledger.block_or_pruned_exists (block_transaction_a, hash_a)) { - nlogger.warn (nano::log::type::node, "Confirmed block is missing: {}", hash_a.to_string ()); + logger.warn (nano::log::type::node, "Confirmed block is missing: {}", hash_a.to_string ()); debug_assert (false, "Confirmed block is missing"); } else { - nlogger.warn (nano::log::type::node, "Block has already been received: {}", hash_a.to_string ()); + logger.warn (nano::log::type::node, "Block has already been received: {}", hash_a.to_string ()); } } } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index f0408d6cc8..65d85830f0 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -146,7 +146,7 @@ class node final : public std::enable_shared_from_this boost::latch node_initialized_latch; nano::node_config config; nano::network_params & network_params; - nano::nlogger nlogger; + nano::logger logger; nano::stats stats; nano::thread_pool workers; nano::thread_pool bootstrap_workers; diff --git a/nano/node/openclwork.cpp b/nano/node/openclwork.cpp index e1d97f4e37..1e8907797d 100644 --- a/nano/node/openclwork.cpp +++ b/nano/node/openclwork.cpp @@ -250,7 +250,7 @@ void nano::opencl_environment::dump (std::ostream & stream) } } -nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::nlogger & nlogger_a, nano::work_thresholds & work) : +nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logger & logger_a, nano::work_thresholds & work) : config (config_a), context (0), attempt_buffer (0), @@ -260,7 +260,7 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf program (0), kernel (0), queue (0), - nlogger (nlogger_a), + logger (logger_a), work{ work } { error_a |= config.platform >= environment_a.platforms.size (); @@ -344,85 +344,85 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf } else { - nlogger.error (nano::log::type::opencl_work, "Bind argument 3 error: {}", arg3_error); + logger.error (nano::log::type::opencl_work, "Bind argument 3 error: {}", arg3_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Bind argument 2 error: {}", arg2_error); + logger.error (nano::log::type::opencl_work, "Bind argument 2 error: {}", arg2_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Bind argument 1 error: {}", arg1_error); + logger.error (nano::log::type::opencl_work, "Bind argument 1 error: {}", arg1_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Bind argument 0 error: {}", arg0_error); + logger.error (nano::log::type::opencl_work, "Bind argument 0 error: {}", arg0_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Create kernel error: {}", kernel_error); + logger.error (nano::log::type::opencl_work, "Create kernel error: {}", kernel_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Build program error: {}", clBuildProgramError); + logger.error (nano::log::type::opencl_work, "Build program error: {}", clBuildProgramError); for (auto i (selected_devices.begin ()), n (selected_devices.end ()); i != n; ++i) { std::size_t log_size (0); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size); std::vector log (log_size); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, log.size (), log.data (), nullptr); - nlogger.info (nano::log::type::opencl_work, "Device log: {}", log.data ()); + logger.info (nano::log::type::opencl_work, "Device log: {}", log.data ()); } } } else { - nlogger.error (nano::log::type::opencl_work, "Create program error: {}", program_error); + logger.error (nano::log::type::opencl_work, "Create program error: {}", program_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Difficulty buffer error: {}", difficulty_error); + logger.error (nano::log::type::opencl_work, "Difficulty buffer error: {}", difficulty_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Item buffer error: {}", item_error); + logger.error (nano::log::type::opencl_work, "Item buffer error: {}", item_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Result buffer error: {}", result_error); + logger.error (nano::log::type::opencl_work, "Result buffer error: {}", result_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Attempt buffer error: {}", attempt_error); + logger.error (nano::log::type::opencl_work, "Attempt buffer error: {}", attempt_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Unable to create command queue: {}", queue_error); + logger.error (nano::log::type::opencl_work, "Unable to create command queue: {}", queue_error); } } else { - nlogger.error (nano::log::type::opencl_work, "Unable to create context: {}", createContextError); + logger.error (nano::log::type::opencl_work, "Unable to create context: {}", createContextError); } } else { - nlogger.error (nano::log::type::opencl_work, "Requested device {} and only have {}", config.device, platform.devices.size ()); + logger.error (nano::log::type::opencl_work, "Requested device {} and only have {}", config.device, platform.devices.size ()); } } else { - nlogger.error (nano::log::type::opencl_work, "Requested platform {} and only have {}", config.platform, environment_a.platforms.size ()); + logger.error (nano::log::type::opencl_work, "Requested platform {} and only have {}", config.platform, environment_a.platforms.size ()); } } @@ -481,37 +481,37 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error finishing queue: {}", finishError); + logger.error (nano::log::type::opencl_work, "Error finishing queue: {}", finishError); } } else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error reading result: {}", read_error1); + logger.error (nano::log::type::opencl_work, "Error reading result: {}", read_error1); } } else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error enqueueing kernel: {}", enqueue_error); + logger.error (nano::log::type::opencl_work, "Error enqueueing kernel: {}", enqueue_error); } } else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error writing difficulty: {}", write_error3); + logger.error (nano::log::type::opencl_work, "Error writing difficulty: {}", write_error3); } } else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error writing item: {}", write_error2); + logger.error (nano::log::type::opencl_work, "Error writing item: {}", write_error2); } } else { error = true; - nlogger.error (nano::log::type::opencl_work, "Error writing attempt: {}", write_error1); + logger.error (nano::log::type::opencl_work, "Error writing attempt: {}", write_error1); } } boost::optional value; @@ -522,7 +522,7 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c return value; } -std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::nlogger & nlogger_a, nano::work_thresholds & work) +std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logger & logger_a, nano::work_thresholds & work) { std::unique_ptr result; if (create_a) @@ -532,11 +532,11 @@ std::unique_ptr nano::opencl_work::create (bool create_a, nan nano::opencl_environment environment (error); std::stringstream stream; environment.dump (stream); - nlogger_a.info (nano::log::type::opencl_work, "OpenCL environment: {}", stream.str ()); + logger_a.info (nano::log::type::opencl_work, "OpenCL environment: {}", stream.str ()); if (!error) { - result.reset (new nano::opencl_work (error, config_a, environment, nlogger_a, work)); + result.reset (new nano::opencl_work (error, config_a, environment, logger_a, work)); if (error) { result.reset (); diff --git a/nano/node/openclwork.hpp b/nano/node/openclwork.hpp index de76e6e416..15173c1dcc 100644 --- a/nano/node/openclwork.hpp +++ b/nano/node/openclwork.hpp @@ -21,7 +21,7 @@ namespace nano { extern bool opencl_loaded; -class nlogger; +class logger; class opencl_platform { public: @@ -40,11 +40,11 @@ class work_pool; class opencl_work { public: - opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::nlogger &, nano::work_thresholds & work); + opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::logger &, nano::work_thresholds & work); ~opencl_work (); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const, std::atomic &); - static std::unique_ptr create (bool, nano::opencl_config const &, nano::nlogger &, nano::work_thresholds & work); + static std::unique_ptr create (bool, nano::opencl_config const &, nano::logger &, nano::work_thresholds & work); nano::opencl_config const & config; nano::mutex mutex; cl_context context; @@ -56,7 +56,7 @@ class opencl_work cl_kernel kernel; cl_command_queue queue; nano::xorshift1024star rand; - nano::nlogger & nlogger; + nano::logger & logger; nano::work_thresholds & work; }; } diff --git a/nano/node/portmapping.cpp b/nano/node/portmapping.cpp index 15a5d08a10..e8d01e847f 100644 --- a/nano/node/portmapping.cpp +++ b/nano/node/portmapping.cpp @@ -62,7 +62,7 @@ void nano::port_mapping::refresh_devices () auto igd_error_l (UPNP_GetValidIGD (upnp_l.devices, &upnp_l.urls, &upnp_l.data, local_address_l.data (), sizeof (local_address_l))); // Bump logging level periodically - node.nlogger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, + node.logger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, nano::log::type::upnp, "UPnP local address {}, discovery: {}, IGD search: {}", local_address_l.data (), discover_error_l, @@ -70,7 +70,7 @@ void nano::port_mapping::refresh_devices () for (auto i (upnp_l.devices); i != nullptr; i = i->pNext) { - node.nlogger.debug (nano::log::type::upnp, "UPnP device url: {}, st: {}, usn: {}", i->descURL, i->st, i->usn); + node.logger.debug (nano::log::type::upnp, "UPnP device url: {}, st: {}, usn: {}", i->descURL, i->st, i->usn); } // Update port mapping @@ -117,7 +117,7 @@ void nano::port_mapping::refresh_mapping () { protocol.external_port = static_cast (std::atoi (config_port_l.data ())); - node.nlogger.info (nano::log::type::upnp, "UPnP {} {}:{} mapped to: {}", + node.logger.info (nano::log::type::upnp, "UPnP {} {}:{} mapped to: {}", protocol.name, protocol.external_address.to_string (), config_port_l, @@ -127,7 +127,7 @@ void nano::port_mapping::refresh_mapping () { protocol.external_port = 0; - node.nlogger.warn (nano::log::type::upnp, "UPnP {} {}:{} failed: {} ({})", + node.logger.warn (nano::log::type::upnp, "UPnP {} {}:{} failed: {} ({})", protocol.name, protocol.external_address.to_string (), config_port_l, @@ -161,7 +161,7 @@ bool nano::port_mapping::check_lost_or_old_mapping () { result_l = true; - node.nlogger.warn (nano::log::type::upnp, "UPnP get specific port mapping failed: {} ({})", + node.logger.warn (nano::log::type::upnp, "UPnP get specific port mapping failed: {} ({})", verify_port_mapping_error_l, strupnperror (verify_port_mapping_error_l)); } @@ -169,7 +169,7 @@ bool nano::port_mapping::check_lost_or_old_mapping () { result_l = true; - node.nlogger.info (nano::log::type::upnp, "UPnP lease time getting old, remaining time: {}, lease time: {}, below the threshold: {}", + node.logger.info (nano::log::type::upnp, "UPnP lease time getting old, remaining time: {}, lease time: {}, below the threshold: {}", remaining_from_port_mapping, lease_duration, lease_duration_divided_by_two); @@ -187,12 +187,12 @@ bool nano::port_mapping::check_lost_or_old_mapping () { protocol.external_address = boost::asio::ip::address_v4::any (); - node.nlogger.warn (nano::log::type::upnp, "UPnP get external ip address failed: {} ({})", + node.logger.warn (nano::log::type::upnp, "UPnP get external ip address failed: {} ({})", external_ip_error_l, strupnperror (external_ip_error_l)); } - node.nlogger.debug (nano::log::type::upnp, "UPnP {} mapping verification response: {}, external ip response: {}, external ip: {}, internal ip: {}, remaining lease: {}", + node.logger.debug (nano::log::type::upnp, "UPnP {} mapping verification response: {}, external ip response: {}, external ip: {}, internal ip: {}, remaining lease: {}", protocol.name, verify_port_mapping_error_l, external_ip_error_l, @@ -219,13 +219,13 @@ void nano::port_mapping::check_mapping_loop () } else { - node.nlogger.info (nano::log::type::upnp, "UPnP No need to refresh the mapping"); + node.logger.info (nano::log::type::upnp, "UPnP No need to refresh the mapping"); } } else { // Bump logging level periodically - node.nlogger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, + node.logger.log ((check_count % 15 == 0) ? nano::log::level::info : nano::log::level::debug, nano::log::type::upnp, "UPnP No IGD devices found"); } @@ -249,14 +249,14 @@ void nano::port_mapping::stop () auto delete_error_l (UPNP_DeletePortMapping (upnp.urls.controlURL, upnp.data.first.servicetype, std::to_string (protocol.external_port).c_str (), protocol.name, address.to_string ().c_str ())); if (delete_error_l) { - node.nlogger.warn (nano::log::type::upnp, "UPnP shutdown {} port mapping failed: {} ({})", + node.logger.warn (nano::log::type::upnp, "UPnP shutdown {} port mapping failed: {} ({})", protocol.name, delete_error_l, strupnperror (delete_error_l)); } else { - node.nlogger.info (nano::log::type::upnp, "UPnP shutdown {} port mapping successful: {}:{}", + node.logger.info (nano::log::type::upnp, "UPnP shutdown {} port mapping successful: {}:{}", protocol.name, protocol.external_address.to_string (), protocol.external_port); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 3c8b251896..8d7bb5ceee 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -45,7 +45,7 @@ void nano::rep_crawler::validate () if (channel->get_type () == nano::transport::transport_type::loopback) { - node.nlogger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); + node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); continue; } @@ -53,7 +53,7 @@ void nano::rep_crawler::validate () nano::uint128_t rep_weight = node.ledger.weight (vote->account); if (rep_weight < minimum) { - node.nlogger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", + node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", vote->account.to_account (), nano::util::to_str (rep_weight)); @@ -93,11 +93,11 @@ void nano::rep_crawler::validate () if (inserted) { - node.nlogger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); + node.logger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); } if (updated) { - node.nlogger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); + node.logger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); } } } diff --git a/nano/node/transport/socket.cpp b/nano/node/transport/socket.cpp index 11b2957f22..609bb75220 100644 --- a/nano/node/transport/socket.cpp +++ b/nano/node/transport/socket.cpp @@ -260,7 +260,7 @@ void nano::transport::socket::ongoing_checkup () if (condition_to_disconnect) { - this_l->node.nlogger.debug (nano::log::type::tcp_server, "Closing socket due to timeout ({})", nano::util::to_str (this_l->remote)); + this_l->node.logger.debug (nano::log::type::tcp_server, "Closing socket due to timeout ({})", nano::util::to_str (this_l->remote)); this_l->timed_out = true; this_l->close (); @@ -335,7 +335,7 @@ void nano::transport::socket::close_internal () if (ec) { node.stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close); - node.nlogger.error (nano::log::type::socket, "Failed to close socket gracefully: {} ({})", ec.message (), nano::util::to_str (remote)); + node.logger.error (nano::log::type::socket, "Failed to close socket gracefully: {} ({})", ec.message (), nano::util::to_str (remote)); } } diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index b1e42c4f21..25fd21a5ba 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -555,7 +555,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a auto query = node_l->network.prepare_handshake_query (endpoint_a); nano::node_id_handshake message{ node_l->network_params.network, query }; - node_l->nlogger.debug (nano::log::type::tcp, "Handshake sent to: {} (query: {})", + node_l->logger.debug (nano::log::type::tcp, "Handshake sent to: {} (query: {})", nano::util::to_str (endpoint_a), (query ? query->cookie.to_string () : "")); @@ -571,7 +571,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a } else { - node_l->nlogger.debug (nano::log::type::tcp, "Error sending handshake to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error sending handshake to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); if (auto socket_l = channel->socket.lock ()) { @@ -585,11 +585,11 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a { if (ec) { - node_l->nlogger.debug (nano::log::type::tcp, "Error connecting to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error connecting to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); } else { - node_l->nlogger.debug (nano::log::type::tcp, "Error connecting to: {}", nano::util::to_str (endpoint_a)); + node_l->logger.debug (nano::log::type::tcp, "Error connecting to: {}", nano::util::to_str (endpoint_a)); } } } @@ -627,7 +627,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnlogger.debug (nano::log::type::tcp, "Error reading handshake from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error reading handshake from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); cleanup_node_id_handshake_socket (endpoint_a); return; @@ -638,7 +638,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrtype () != nano::message_type::node_id_handshake) { - node_l->nlogger.debug (nano::log::type::tcp, "Error reading handshake header from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error reading handshake header from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); cleanup_node_id_handshake_socket (endpoint_a); return; @@ -668,7 +668,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnlogger.debug (nano::log::type::tcp, "Error reading handshake payload from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error reading handshake payload from: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); cleanup_node_id_handshake_socket (endpoint_a); return; @@ -702,7 +702,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnetwork.prepare_handshake_response (*handshake.query, handshake.is_v2 ()); nano::node_id_handshake handshake_response (node_l->network_params.network, std::nullopt, response); - node_l->nlogger.debug (nano::log::type::tcp, "Handshake response sent to {} (query: {})", + node_l->logger.debug (nano::log::type::tcp, "Handshake response sent to {} (query: {})", nano::util::to_str (endpoint_a), handshake.query->cookie.to_string ()); @@ -714,7 +714,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnlogger.debug (nano::log::type::tcp, "Error sending handshake response to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); + node_l->logger.debug (nano::log::type::tcp, "Error sending handshake response to: {} ({})", nano::util::to_str (endpoint_a), ec.message ()); cleanup_node_id_handshake_socket (endpoint_a); return; diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 83dfef4924..9d02482b11 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -56,7 +56,7 @@ void nano::transport::tcp_listener::start (std::functionacceptor.is_open ()) { - this_l->node.nlogger.error (nano::log::type::tcp_listener, "Acceptor is not open"); + this_l->node.logger.error (nano::log::type::tcp_listener, "Acceptor is not open"); return; } @@ -139,7 +139,7 @@ void nano::transport::tcp_listener::on_connection (std::functionconnections_per_address.size () >= this_l->max_inbound_connections) { this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); - this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections reached ({}), unable to open new connection", this_l->connections_per_address.size ()); + this_l->node.logger.debug (nano::log::type::tcp_listener, "Max connections reached ({}), unable to open new connection", this_l->connections_per_address.size ()); this_l->on_connection_requeue_delayed (std::move (cbk)); return; @@ -148,7 +148,7 @@ void nano::transport::tcp_listener::on_connection (std::functionlimit_reached_for_incoming_ip_connections (new_connection)) { this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::in); - this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections per IP reached ({}), unable to open new connection", new_connection->remote_endpoint ().address ().to_string ()); + this_l->node.logger.debug (nano::log::type::tcp_listener, "Max connections per IP reached ({}), unable to open new connection", new_connection->remote_endpoint ().address ().to_string ()); this_l->on_connection_requeue_delayed (std::move (cbk)); return; @@ -161,7 +161,7 @@ void nano::transport::tcp_listener::on_connection (std::functionnode.network_params.network.max_peers_per_subnetwork); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::in); - this_l->node.nlogger.debug (nano::log::type::tcp_listener, "Max connections per subnetwork reached (subnetwork: {}, ip: {}), unable to open new connection", + this_l->node.logger.debug (nano::log::type::tcp_listener, "Max connections per subnetwork reached (subnetwork: {}, ip: {}), unable to open new connection", remote_subnet.canonical ().to_string (), remote_ip_address.to_string ()); @@ -189,13 +189,13 @@ void nano::transport::tcp_listener::on_connection (std::functionon_connection (std::move (cbk)); return; } - this_l->node.nlogger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); + this_l->node.logger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); return; } // accept error this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); - this_l->node.nlogger.error (nano::log::type::tcp_listener, "Unable to accept connection: {} ({})", ec_a.message (), new_connection->remote_endpoint ().address ().to_string ()); + this_l->node.logger.error (nano::log::type::tcp_listener, "Unable to accept connection: {} ({})", ec_a.message (), new_connection->remote_endpoint ().address ().to_string ()); if (is_temporary_error (ec_a)) { @@ -212,7 +212,7 @@ void nano::transport::tcp_listener::on_connection (std::functionnode.nlogger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); + this_l->node.logger.warn (nano::log::type::tcp_listener, "Stopping to accept new connections"); })); })); } @@ -254,7 +254,7 @@ void nano::transport::tcp_listener::accept_action (boost::system::error_code con else { node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_excluded); - node.nlogger.debug (nano::log::type::tcp_server, "Rejected connection from excluded peer: {}", nano::util::to_str (socket_a->remote_endpoint ())); + node.logger.debug (nano::log::type::tcp_server, "Rejected connection from excluded peer: {}", nano::util::to_str (socket_a->remote_endpoint ())); } } @@ -306,7 +306,7 @@ nano::transport::tcp_server::~tcp_server () return; } - node->nlogger.debug (nano::log::type::tcp_server, "Exiting TCP server ({})", nano::util::to_str (remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Exiting TCP server ({})", nano::util::to_str (remote_endpoint)); if (socket->type () == nano::transport::socket::type_t::bootstrap) { @@ -342,7 +342,7 @@ void nano::transport::tcp_server::start () if (auto node_l = node.lock (); node_l) { - node_l->nlogger.debug (nano::log::type::tcp_server, "Starting TCP server ({})", nano::util::to_str (remote_endpoint)); + node_l->logger.debug (nano::log::type::tcp_server, "Starting TCP server ({})", nano::util::to_str (remote_endpoint)); } receive_message (); @@ -373,7 +373,7 @@ void nano::transport::tcp_server::receive_message () { // IO error or critical error when deserializing message node->stats.inc (nano::stat::type::error, nano::to_stat_detail (this_l->message_deserializer->status)); - node->nlogger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})", + node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})", ec.message (), nano::to_string (this_l->message_deserializer->status), nano::util::to_str (this_l->remote_endpoint)); @@ -412,7 +412,7 @@ void nano::transport::tcp_server::received_message (std::unique_ptrnlogger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})", + node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})", nano::to_string (message_deserializer->status), nano::util::to_str (remote_endpoint)); } @@ -466,7 +466,7 @@ bool nano::transport::tcp_server::process_message (std::unique_ptrnlogger.debug (nano::log::type::tcp_server, "Neither handshake nor bootstrap received when in handshake mode: {} ({})", + node->logger.debug (nano::log::type::tcp_server, "Neither handshake nor bootstrap received when in handshake mode: {} ({})", nano::to_string (message->header.type), nano::util::to_str (remote_endpoint)); @@ -522,7 +522,7 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( } if (node->flags.disable_tcp_realtime) { - node->nlogger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime TCP ({})", nano::util::to_str (server->remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime TCP ({})", nano::util::to_str (server->remote_endpoint)); // Stop invalid handshake server->stop (); @@ -531,7 +531,7 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( if (message.query && server->handshake_query_received) { - node->nlogger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", nano::util::to_str (server->remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", nano::util::to_str (server->remote_endpoint)); // Stop invalid handshake server->stop (); @@ -540,7 +540,7 @@ void nano::transport::tcp_server::handshake_message_visitor::node_id_handshake ( server->handshake_query_received = true; - node->nlogger.debug (nano::log::type::tcp_server, "Handshake query received ({})", nano::util::to_str (server->remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Handshake query received ({})", nano::util::to_str (server->remote_endpoint)); if (message.query) { @@ -584,7 +584,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha } if (ec) { - node->nlogger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), nano::util::to_str (this_l->remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), nano::util::to_str (this_l->remote_endpoint)); // Stop invalid handshake this_l->stop (); @@ -781,7 +781,7 @@ void nano::transport::tcp_server::timeout () } if (socket->has_timed_out ()) { - node->nlogger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", nano::util::to_str (remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", nano::util::to_str (remote_endpoint)); { nano::lock_guard lock{ node->tcp_listener->mutex }; @@ -818,7 +818,7 @@ bool nano::transport::tcp_server::to_bootstrap_connection () ++node->tcp_listener->bootstrap_count; socket->type_set (nano::transport::socket::type_t::bootstrap); - node->nlogger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", nano::util::to_str (remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", nano::util::to_str (remote_endpoint)); return true; } @@ -836,7 +836,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const & ++node->tcp_listener->realtime_count; socket->type_set (nano::transport::socket::type_t::realtime); - node->nlogger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", nano::util::to_str (remote_endpoint)); + node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", nano::util::to_str (remote_endpoint)); return true; } diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 522cba1aba..0885da8332 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -15,12 +15,12 @@ #include using namespace std::chrono_literals; -nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::nlogger & nlogger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : +nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : active (active_a), observers (observers_a), stats (stats_a), config (config_a), - nlogger (nlogger_a), + logger (logger_a), online_reps (online_reps_a), rep_crawler (rep_crawler_a), ledger (ledger_a), @@ -77,7 +77,7 @@ void nano::vote_processor::process_loop () if (log_this_iteration && elapsed.stop () > std::chrono::milliseconds (100)) { - nlogger.debug (nano::log::type::vote_processor, "Processed {} votes in {} milliseconds (rate of {} votes per second)", + logger.debug (nano::log::type::vote_processor, "Processed {} votes in {} milliseconds (rate of {} votes per second)", votes_l.size (), elapsed.value ().count (), ((votes_l.size () * 1000ULL) / elapsed.value ().count ())); @@ -199,7 +199,7 @@ void nano::vote_processor::flush () }); if (!success) { - nlogger.error (nano::log::type::vote_processor, "Flush timeout"); + logger.error (nano::log::type::vote_processor, "Flush timeout"); debug_assert (false && "vote_processor::flush timeout while waiting for flush"); } } diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index 6ae37d16b2..dbcacc41c3 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -20,7 +20,7 @@ namespace store class node_observers; class stats; class node_config; -class nlogger; +class logger; class online_reps; class rep_crawler; class ledger; @@ -36,7 +36,7 @@ namespace transport class vote_processor final { public: - vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::nlogger &, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); + vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger &, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); /** Returns false if the vote was processed */ bool vote (std::shared_ptr const &, std::shared_ptr const &); @@ -60,7 +60,7 @@ class vote_processor final nano::node_observers & observers; nano::stats & stats; nano::node_config & config; - nano::nlogger & nlogger; + nano::logger & logger; nano::online_reps & online_reps; nano::rep_crawler & rep_crawler; nano::ledger & ledger; diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 6ce77661ed..3f29a80a0e 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -699,7 +699,7 @@ bool nano::wallet::enter_password (store::transaction const & transaction_a, std auto result (store.attempt_password (transaction_a, password_a)); if (!result) { - wallets.node.nlogger.info (nano::log::type::wallet, "Wallet unlocked"); + wallets.node.logger.info (nano::log::type::wallet, "Wallet unlocked"); auto this_l = shared_from_this (); wallets.node.wallets.queue_wallet_action (nano::wallets::high_priority, this_l, [this_l] (nano::wallet & wallet) { @@ -709,7 +709,7 @@ bool nano::wallet::enter_password (store::transaction const & transaction_a, std } else { - wallets.node.nlogger.warn (nano::log::type::wallet, "Invalid password, wallet locked"); + wallets.node.logger.warn (nano::log::type::wallet, "Invalid password, wallet locked"); } lock_observer (result, password_a.empty ()); return result; @@ -866,7 +866,7 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons } else { - wallets.node.nlogger.warn (nano::log::type::wallet, "Unable to receive, wallet locked"); + wallets.node.logger.warn (nano::log::type::wallet, "Unable to receive, wallet locked"); } } else @@ -882,7 +882,7 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons else { // Someone sent us something below the threshold of receiving - wallets.node.nlogger.warn (nano::log::type::wallet, "Not receiving block {} due to minimum receive threshold", send_hash_a.to_string ()); + wallets.node.logger.warn (nano::log::type::wallet, "Not receiving block {} due to minimum receive threshold", send_hash_a.to_string ()); } if (block != nullptr) { @@ -1044,7 +1044,7 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a auto required_difficulty{ wallets.node.network_params.work.threshold (block_a->work_version (), details_a) }; if (wallets.node.network_params.work.difficulty (*block_a) < required_difficulty) { - wallets.node.nlogger.info (nano::log::type::wallet, "Cached or provided work for block {} account {} is invalid, regenerating...", + wallets.node.logger.info (nano::log::type::wallet, "Cached or provided work for block {} account {} is invalid, regenerating...", block_a->hash ().to_string (), account_a.to_account ()); @@ -1143,7 +1143,7 @@ void nano::wallet::work_update (store::transaction const & transaction_a, nano:: } else { - wallets.node.nlogger.warn (nano::log::type::wallet, "Cached work no longer valid, discarding"); + wallets.node.logger.warn (nano::log::type::wallet, "Cached work no longer valid, discarding"); } } @@ -1172,7 +1172,7 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact auto result (!store.valid_password (wallet_transaction_a)); if (!result) { - wallets.node.nlogger.info (nano::log::type::wallet, "Beginning receivable block search"); + wallets.node.logger.info (nano::log::type::wallet, "Beginning receivable block search"); for (auto i (store.begin (wallet_transaction_a)), n (store.end ()); i != n; ++i) { @@ -1189,7 +1189,7 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact auto amount (pending.amount.number ()); if (wallets.node.config.receive_minimum.number () <= amount) { - wallets.node.nlogger.info (nano::log::type::wallet, "Found a receivable block {} for account {}", hash.to_string (), pending.source.to_account ()); + wallets.node.logger.info (nano::log::type::wallet, "Found a receivable block {} for account {}", hash.to_string (), pending.source.to_account ()); if (wallets.node.ledger.block_confirmed (block_transaction, hash)) { @@ -1211,11 +1211,11 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact } } - wallets.node.nlogger.info (nano::log::type::wallet, "Receivable block search phase complete"); + wallets.node.logger.info (nano::log::type::wallet, "Receivable block search phase complete"); } else { - wallets.node.nlogger.warn (nano::log::type::wallet, "Stopping search, wallet is locked"); + wallets.node.logger.warn (nano::log::type::wallet, "Stopping search, wallet is locked"); } return result; } @@ -1307,7 +1307,7 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::r } else if (!wallets.node.stopped) { - wallets.node.nlogger.warn (nano::log::type::wallet, "Could not precache work for root {} due to work generation failure", root_a.to_string ()); + wallets.node.logger.warn (nano::log::type::wallet, "Could not precache work for root {} due to work generation failure", root_a.to_string ()); } } } @@ -1395,7 +1395,7 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) : char const * store_path; mdb_env_get_path (env, &store_path); std::filesystem::path const path (store_path); - nano::store::lmdb::component::create_backup_file (env, path, node_a.nlogger); + nano::store::lmdb::component::create_backup_file (env, path, node_a.logger); } for (auto & item : items) { @@ -1569,7 +1569,7 @@ void nano::wallets::foreach_representative (std::functionfirst.to_string ()); + node.logger.warn (nano::log::type::wallet, "Representative locked inside wallet: {}", i->first.to_string ()); } } } diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index a58a2a5247..c2b3af2f98 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -15,15 +15,15 @@ #include #include -nano::websocket::confirmation_options::confirmation_options (nano::wallets & wallets_a, nano::nlogger & nlogger_a) : +nano::websocket::confirmation_options::confirmation_options (nano::wallets & wallets_a, nano::logger & logger_a) : wallets (wallets_a), - nlogger (nlogger_a) + logger (logger_a) { } -nano::websocket::confirmation_options::confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::nlogger & nlogger_a) : +nano::websocket::confirmation_options::confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::logger & logger_a) : wallets (wallets_a), - nlogger (nlogger_a) + logger (logger_a) { // Non-account filtering options include_block = options_a.get ("include_block", true); @@ -64,7 +64,7 @@ nano::websocket::confirmation_options::confirmation_options (boost::property_tre if (!include_block) { - nlogger.warn (nano::log::type::websocket, "Filtering option \"all_local_accounts\" requires that \"include_block\" is set to true to be effective"); + logger.warn (nano::log::type::websocket, "Filtering option \"all_local_accounts\" requires that \"include_block\" is set to true to be effective"); } } auto accounts_l (options_a.get_child_optional ("accounts")); @@ -81,13 +81,13 @@ nano::websocket::confirmation_options::confirmation_options (boost::property_tre } else { - nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); + logger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); } } if (!include_block) { - nlogger.warn (nano::log::type::websocket, "Filtering option \"accounts\" requires that \"include_block\" is set to true to be effective"); + logger.warn (nano::log::type::websocket, "Filtering option \"accounts\" requires that \"include_block\" is set to true to be effective"); } } check_filter_empty (); @@ -162,7 +162,7 @@ bool nano::websocket::confirmation_options::update (boost::property_tree::ptree } else { - nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); + logger.warn (nano::log::type::websocket, "Invalid account provided for filtering blocks: ", account_l.second.data ()); } } }; @@ -190,11 +190,11 @@ void nano::websocket::confirmation_options::check_filter_empty () const // Warn the user if the options resulted in an empty filter if (has_account_filtering_options && !all_local_accounts && accounts.empty ()) { - nlogger.warn (nano::log::type::websocket, "Provided options resulted in an empty account confirmation filter"); + logger.warn (nano::log::type::websocket, "Provided options resulted in an empty account confirmation filter"); } } -nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & options_a, nano::nlogger & nlogger) +nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & options_a, nano::logger & logger) { include_replays = options_a.get ("include_replays", false); include_indeterminate = options_a.get ("include_indeterminate", false); @@ -211,13 +211,13 @@ nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & } else { - nlogger.warn (nano::log::type::websocket, "Invalid account provided for filtering votes: ", representative_l.second.data ()); + logger.warn (nano::log::type::websocket, "Invalid account provided for filtering votes: ", representative_l.second.data ()); } } // Warn the user if the option will be ignored if (representatives.empty ()) { - nlogger.warn (nano::log::type::websocket, "Account filter for votes is empty, no messages will be filtered"); + logger.warn (nano::log::type::websocket, "Account filter for votes is empty, no messages will be filtered"); } } } @@ -246,10 +246,10 @@ nano::websocket::session::session (nano::websocket::listener & listener_a, socke #endif -nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a, nano::nlogger & nlogger_a) : +nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a, nano::logger & logger_a) : ws_listener (listener_a), ws (std::move (socket_a)), - nlogger (nlogger_a) + logger (logger_a) { { // Best effort attempt to get endpoint addresses @@ -260,7 +260,7 @@ nano::websocket::session::session (nano::websocket::listener & listener_a, socke debug_assert (!ec); } - nlogger.info (nano::log::type::websocket, "Session started ({})", nano::util::to_str (remote)); + logger.info (nano::log::type::websocket, "Session started ({})", nano::util::to_str (remote)); } nano::websocket::session::~session () @@ -285,14 +285,14 @@ void nano::websocket::session::handshake () } else { - this_l->nlogger.error (nano::log::type::websocket, "Handshake failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); + this_l->logger.error (nano::log::type::websocket, "Handshake failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); } }); } void nano::websocket::session::close () { - nlogger.info (nano::log::type::websocket, "Session closing ({})", nano::util::to_str (remote)); + logger.info (nano::log::type::websocket, "Session closing ({})", nano::util::to_str (remote)); auto this_l (shared_from_this ()); boost::asio::dispatch (ws.get_strand (), @@ -368,12 +368,12 @@ void nano::websocket::session::read () } catch (boost::property_tree::json_parser::json_parser_error const & ex) { - this_l->nlogger.error (nano::log::type::websocket, "JSON parsing failed: {} ({})", ex.what (), nano::util::to_str (this_l->remote)); + this_l->logger.error (nano::log::type::websocket, "JSON parsing failed: {} ({})", ex.what (), nano::util::to_str (this_l->remote)); } } else if (ec != boost::asio::error::eof) { - this_l->nlogger.error (nano::log::type::websocket, "Read failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); + this_l->logger.error (nano::log::type::websocket, "Read failed: {} ({})", ec.message (), nano::util::to_str (this_l->remote)); } }); }); @@ -495,11 +495,11 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const std::unique_ptr options_l{ nullptr }; if (options_text_l && topic_l == nano::websocket::topic::confirmation) { - options_l = std::make_unique (options_text_l.get (), ws_listener.get_wallets (), nlogger); + options_l = std::make_unique (options_text_l.get (), ws_listener.get_wallets (), logger); } else if (options_text_l && topic_l == nano::websocket::topic::vote) { - options_l = std::make_unique (options_text_l.get (), nlogger); + options_l = std::make_unique (options_text_l.get (), logger); } else { @@ -508,13 +508,13 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const auto existing (subscriptions.find (topic_l)); if (existing != subscriptions.end ()) { - nlogger.info (nano::log::type::websocket, "Updated subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + logger.info (nano::log::type::websocket, "Updated subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); existing->second = std::move (options_l); } else { - nlogger.info (nano::log::type::websocket, "New subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + logger.info (nano::log::type::websocket, "New subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); subscriptions.emplace (topic_l, std::move (options_l)); ws_listener.increase_subscriber_count (topic_l); @@ -539,7 +539,7 @@ void nano::websocket::session::handle_message (boost::property_tree::ptree const nano::lock_guard lk (subscriptions_mutex); if (subscriptions.erase (topic_l)) { - nlogger.info (nano::log::type::websocket, "Removed subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); + logger.info (nano::log::type::websocket, "Removed subscription to topic: {} ({})", from_topic (topic_l), nano::util::to_str (remote)); ws_listener.decrease_subscriber_count (topic_l); } @@ -574,9 +574,9 @@ void nano::websocket::listener::stop () sessions.clear (); } -nano::websocket::listener::listener (std::shared_ptr const & tls_config_a, nano::nlogger & nlogger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : +nano::websocket::listener::listener (std::shared_ptr const & tls_config_a, nano::logger & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : tls_config (tls_config_a), - nlogger (nlogger_a), + logger (logger_a), wallets (wallets_a), acceptor (io_ctx_a), socket (io_ctx_a) @@ -594,7 +594,7 @@ nano::websocket::listener::listener (std::shared_ptr const & t } catch (std::exception const & ex) { - nlogger.error (nano::log::type::websocket, "Listen failed: {}", ex.what ()); + logger.error (nano::log::type::websocket, "Listen failed: {}", ex.what ()); } } @@ -619,7 +619,7 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec) { if (ec) { - nlogger.error (nano::log::type::websocket, "Accept failed: {}", ec.message ()); + logger.error (nano::log::type::websocket, "Accept failed: {}", ec.message ()); } else { @@ -633,7 +633,7 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec) } else { - session = std::make_shared (*this, std::move (socket), nlogger); + session = std::make_shared (*this, std::move (socket), logger); } sessions_mutex.lock (); @@ -665,7 +665,7 @@ void nano::websocket::listener::broadcast_confirmation (std::shared_ptrsubscriptions.find (nano::websocket::topic::confirmation)); if (subscription != session_ptr->subscriptions.end ()) { - nano::websocket::confirmation_options default_options (wallets, nlogger); + nano::websocket::confirmation_options default_options (wallets, logger); auto conf_options (dynamic_cast (subscription->second.get ())); if (conf_options == nullptr) { @@ -982,13 +982,13 @@ std::string nano::websocket::message::to_string () const * websocket_server */ -nano::websocket_server::websocket_server (nano::websocket::config & config_a, nano::node_observers & observers_a, nano::wallets & wallets_a, nano::ledger & ledger_a, boost::asio::io_context & io_ctx_a, nano::nlogger & nlogger_a) : +nano::websocket_server::websocket_server (nano::websocket::config & config_a, nano::node_observers & observers_a, nano::wallets & wallets_a, nano::ledger & ledger_a, boost::asio::io_context & io_ctx_a, nano::logger & logger_a) : config{ config_a }, observers{ observers_a }, wallets{ wallets_a }, ledger{ ledger_a }, io_ctx{ io_ctx_a }, - nlogger{ nlogger_a } + logger{ logger_a } { if (!config.enabled) { @@ -996,7 +996,7 @@ nano::websocket_server::websocket_server (nano::websocket::config & config_a, na } auto endpoint = nano::tcp_endpoint{ boost::asio::ip::make_address_v6 (config.address), config.port }; - server = std::make_shared (config.tls_config, nlogger, wallets, io_ctx, endpoint); + server = std::make_shared (config.tls_config, logger, wallets, io_ctx, endpoint); observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { debug_assert (status_a.type != nano::election_status_type::ongoing); diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 84fdf60c8d..6bb7426a0b 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -21,7 +21,7 @@ namespace nano { class wallets; -class nlogger; +class logger; class vote; class election_status; class telemetry_data; @@ -142,8 +142,8 @@ namespace websocket class confirmation_options final : public options { public: - confirmation_options (nano::wallets & wallets_a, nano::nlogger &); - confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::nlogger &); + confirmation_options (nano::wallets & wallets_a, nano::logger &); + confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::logger &); /** * Checks if a message should be filtered for given block confirmation options. @@ -195,7 +195,7 @@ namespace websocket void check_filter_empty () const; nano::wallets & wallets; - nano::nlogger & nlogger; + nano::logger & logger; bool include_election_info{ false }; bool include_election_info_with_votes{ false }; @@ -215,7 +215,7 @@ namespace websocket class vote_options final : public options { public: - vote_options (boost::property_tree::ptree const & options_a, nano::nlogger &); + vote_options (boost::property_tree::ptree const & options_a, nano::logger &); /** * Checks if a message should be filtered for given vote received options. @@ -241,7 +241,7 @@ namespace websocket explicit session (nano::websocket::listener & listener_a, socket_type socket_a, boost::asio::ssl::context & ctx_a); #endif /** Constructor that takes ownership over \p socket_a */ - explicit session (nano::websocket::listener & listener_a, socket_type socket_a, nano::nlogger &); + explicit session (nano::websocket::listener & listener_a, socket_type socket_a, nano::logger &); ~session (); @@ -262,7 +262,7 @@ namespace websocket nano::websocket::listener & ws_listener; /** Websocket stream, supporting both plain and tls connections */ nano::websocket::stream ws; - nano::nlogger & nlogger; + nano::logger & logger; /** Buffer for received messages */ boost::beast::multi_buffer read_buffer; @@ -298,7 +298,7 @@ namespace websocket class listener final : public std::enable_shared_from_this { public: - listener (std::shared_ptr const & tls_config_a, nano::nlogger &, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); + listener (std::shared_ptr const & tls_config_a, nano::logger &, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); /** Start accepting connections */ void run (); @@ -348,7 +348,7 @@ namespace websocket void decrease_subscriber_count (nano::websocket::topic const & topic_a); std::shared_ptr tls_config; - nano::nlogger & nlogger; + nano::logger & logger; nano::wallets & wallets; boost::asio::ip::tcp::acceptor acceptor; socket_type socket; @@ -365,7 +365,7 @@ namespace websocket class websocket_server { public: - websocket_server (nano::websocket::config &, nano::node_observers &, nano::wallets &, nano::ledger &, boost::asio::io_context &, nano::nlogger &); + websocket_server (nano::websocket::config &, nano::node_observers &, nano::wallets &, nano::ledger &, boost::asio::io_context &, nano::logger &); void start (); void stop (); @@ -376,7 +376,7 @@ class websocket_server nano::wallets & wallets; nano::ledger & ledger; boost::asio::io_context & io_ctx; - nano::nlogger & nlogger; + nano::logger & logger; public: // TODO: Encapsulate, this is public just because existing code needs it diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 7daf3a36fe..2b83d7d61a 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -1546,7 +1546,7 @@ nano_qt::settings::settings (nano_qt::wallet & wallet_a) : retype_password->setPlaceholderText ("Retype password"); show_button_success (*change); change->setText ("Password was changed"); - this->wallet.node.nlogger.warn (nano::log::type::qt, "Wallet password changed"); + this->wallet.node.logger.warn (nano::log::type::qt, "Wallet password changed"); update_locked (false, false); this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () { this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () { @@ -1639,7 +1639,7 @@ nano_qt::settings::settings (nano_qt::wallet & wallet_a) : this->wallet.wallet_m->store.password.value_set (empty); update_locked (true, true); lock_toggle->setText ("Unlock"); - this->wallet.node.nlogger.warn (nano::log::type::qt, "Wallet locked"); + this->wallet.node.logger.warn (nano::log::type::qt, "Wallet locked"); password->setEnabled (1); } else diff --git a/nano/qt_test/entry.cpp b/nano/qt_test/entry.cpp index a34cb347dd..e8976178c4 100644 --- a/nano/qt_test/entry.cpp +++ b/nano/qt_test/entry.cpp @@ -17,7 +17,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); + nano::logger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; QApplication application (argc, argv); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 8735ef9a06..b7b6621ae3 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -522,8 +522,8 @@ TEST (history, short_text) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - nano::nlogger nlogger; - auto store = nano::make_store (nlogger, nano::unique_path (), nano::dev::constants); + nano::logger logger; + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); { @@ -560,8 +560,8 @@ TEST (history, pruned_source) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - nano::nlogger nlogger; - auto store = nano::make_store (nlogger, nano::unique_path (), nano::dev::constants); + nano::logger logger; + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); ledger.pruning = true; diff --git a/nano/rpc/rpc.cpp b/nano/rpc/rpc.cpp index 6209810352..687c9b316e 100644 --- a/nano/rpc/rpc.cpp +++ b/nano/rpc/rpc.cpp @@ -36,7 +36,7 @@ void nano::rpc::start () bool const is_loopback = (endpoint.address ().is_loopback () || (endpoint.address ().to_v6 ().is_v4_mapped () && boost::asio::ip::make_address_v4 (boost::asio::ip::v4_mapped, endpoint.address ().to_v6 ()).is_loopback ())); if (!is_loopback && config.enable_control) { - nlogger.warn (nano::log::type::rpc, "WARNING: Control-level RPCs are enabled on non-local address {}, potentially allowing wallet access outside local computer", endpoint.address ().to_string ()); + logger.warn (nano::log::type::rpc, "WARNING: Control-level RPCs are enabled on non-local address {}, potentially allowing wallet access outside local computer", endpoint.address ().to_string ()); } acceptor.open (endpoint.protocol ()); @@ -46,7 +46,7 @@ void nano::rpc::start () acceptor.bind (endpoint, ec); if (ec) { - nlogger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ()); + logger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ()); throw std::runtime_error (ec.message ()); } acceptor.listen (); @@ -55,7 +55,7 @@ void nano::rpc::start () void nano::rpc::accept () { - auto connection (std::make_shared (config, io_ctx, nlogger, rpc_handler_interface)); + auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) { if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { @@ -67,7 +67,7 @@ void nano::rpc::accept () } else { - nlogger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); + logger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); } })); } diff --git a/nano/rpc/rpc.hpp b/nano/rpc/rpc.hpp index 695de1467a..99f66b260a 100644 --- a/nano/rpc/rpc.hpp +++ b/nano/rpc/rpc.hpp @@ -31,7 +31,7 @@ class rpc return acceptor.local_endpoint ().port (); } - nano::nlogger nlogger{ "rpc" }; + nano::logger logger{ "rpc" }; nano::rpc_config config; boost::asio::ip::tcp::acceptor acceptor; boost::asio::io_context & io_ctx; diff --git a/nano/rpc/rpc_connection.cpp b/nano/rpc/rpc_connection.cpp index f8c4b34b59..d7c71562c1 100644 --- a/nano/rpc/rpc_connection.cpp +++ b/nano/rpc/rpc_connection.cpp @@ -13,11 +13,11 @@ #endif #include -nano::rpc_connection::rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::nlogger & nlogger, nano::rpc_handler_interface & rpc_handler_interface) : +nano::rpc_connection::rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger & logger, nano::rpc_handler_interface & rpc_handler_interface) : socket (io_ctx), strand (io_ctx.get_executor ()), io_ctx (io_ctx), - nlogger (nlogger), + logger (logger), rpc_config (rpc_config), rpc_handler_interface (rpc_handler_interface) { @@ -83,7 +83,7 @@ void nano::rpc_connection::read (STREAM_TYPE & stream) } else { - this_l->nlogger.error (nano::log::type::rpc_connection, "RPC header error: ", ec.message ()); + this_l->logger.error (nano::log::type::rpc_connection, "RPC header error: ", ec.message ()); // Respond with the reason for the invalid header auto response_handler ([this_l, &stream] (std::string const & tree_a) { @@ -123,7 +123,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< })); // Bump logging level if RPC request logging is enabled - this_l->nlogger.log (this_l->rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, + this_l->logger.log (this_l->rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, nano::log::type::rpc_request, "RPC request {} completed in {} microseconds", request_id, std::chrono::duration_cast (std::chrono::steady_clock::now () - start).count ()); }); @@ -135,7 +135,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< { case boost::beast::http::verb::post: { - auto handler (std::make_shared (this_l->rpc_config, req.body (), request_id, response_handler, this_l->rpc_handler_interface, this_l->nlogger)); + auto handler (std::make_shared (this_l->rpc_config, req.body (), request_id, response_handler, this_l->rpc_handler_interface, this_l->logger)); nano::rpc_handler_request_params request_params; request_params.rpc_version = rpc_version_l; request_params.credentials = header_field_credentials_l; @@ -164,7 +164,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr< } else { - this_l->nlogger.error (nano::log::type::rpc_connection, "RPC read error: ", ec.message ()); + this_l->logger.error (nano::log::type::rpc_connection, "RPC read error: ", ec.message ()); } })); } diff --git a/nano/rpc/rpc_connection.hpp b/nano/rpc/rpc_connection.hpp index da37b47e6d..960e0b31fa 100644 --- a/nano/rpc/rpc_connection.hpp +++ b/nano/rpc/rpc_connection.hpp @@ -25,7 +25,7 @@ class rpc_handler_interface; class rpc_connection : public std::enable_shared_from_this { public: - rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::nlogger &, nano::rpc_handler_interface & rpc_handler_interface_a); + rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger &, nano::rpc_handler_interface & rpc_handler_interface_a); virtual ~rpc_connection () = default; virtual void parse_connection (); virtual void write_completion_handler (std::shared_ptr const & rpc_connection); @@ -38,7 +38,7 @@ class rpc_connection : public std::enable_shared_from_this boost::asio::strand strand; std::atomic_flag responded; boost::asio::io_context & io_ctx; - nano::nlogger & nlogger; + nano::logger & logger; nano::rpc_config const & rpc_config; nano::rpc_handler_interface & rpc_handler_interface; diff --git a/nano/rpc/rpc_handler.cpp b/nano/rpc/rpc_handler.cpp index a4e5f05dac..241c46c47c 100644 --- a/nano/rpc/rpc_handler.cpp +++ b/nano/rpc/rpc_handler.cpp @@ -17,13 +17,13 @@ std::unordered_set rpc_control_impl_set = create_rpc_control_impls std::string filter_request (boost::property_tree::ptree tree_a); } -nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::nlogger & nlogger) : +nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger & logger) : body (body_a), request_id (request_id_a), response (response_a), rpc_config (rpc_config), rpc_handler_interface (rpc_handler_interface_a), - nlogger (nlogger) + logger (logger) { } @@ -63,7 +63,7 @@ void nano::rpc_handler::process_request (nano::rpc_handler_request_params const auto action = request.get ("action"); // Bump logging level if RPC request logging is enabled - nlogger.log (rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, + logger.log (rpc_config.rpc_logging.log_rpc ? nano::log::level::info : nano::log::level::debug, nano::log::type::rpc_request, "Request {} : {}", request_id, filter_request (request)); // Check if this is a RPC command which requires RPC enabled control diff --git a/nano/rpc/rpc_handler.hpp b/nano/rpc/rpc_handler.hpp index b8fd6093ce..55a979fa07 100644 --- a/nano/rpc/rpc_handler.hpp +++ b/nano/rpc/rpc_handler.hpp @@ -16,7 +16,7 @@ class rpc_handler_request_params; class rpc_handler : public std::enable_shared_from_this { public: - rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::nlogger &); + rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger &); void process_request (nano::rpc_handler_request_params const & request_params); private: @@ -26,6 +26,6 @@ class rpc_handler : public std::enable_shared_from_this std::function response; nano::rpc_config const & rpc_config; nano::rpc_handler_interface & rpc_handler_interface; - nano::nlogger & nlogger; + nano::logger & logger; }; } diff --git a/nano/rpc/rpc_secure.cpp b/nano/rpc/rpc_secure.cpp index 8548a8f843..9640e28c2f 100644 --- a/nano/rpc/rpc_secure.cpp +++ b/nano/rpc/rpc_secure.cpp @@ -15,7 +15,7 @@ nano::rpc_secure::rpc_secure (boost::asio::io_context & context_a, nano::rpc_con void nano::rpc_secure::accept () { - auto connection (std::make_shared (config, io_ctx, nlogger, rpc_handler_interface, config.tls_config->ssl_context)); + auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface, config.tls_config->ssl_context)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) { if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { @@ -27,7 +27,7 @@ void nano::rpc_secure::accept () } else { - nlogger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); + logger.error (nano::log::type::rpc, "Error accepting RPC connection: {}", ec.message ()); } })); } diff --git a/nano/rpc_test/entry.cpp b/nano/rpc_test/entry.cpp index be70e1183e..2a94b7d9e7 100644 --- a/nano/rpc_test/entry.cpp +++ b/nano/rpc_test/entry.cpp @@ -15,7 +15,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); + nano::logger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::set_use_memory_pools (false); nano::node_singleton_memory_pool_purge_guard cleanup_guard; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index e7c511b8bd..0fc1ecd604 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1559,13 +1559,13 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (std::filesystem::path const & data_p auto rockdb_data_path = data_path_a / "rocksdb"; std::filesystem::remove_all (rockdb_data_path); - nano::nlogger nlogger; + nano::logger logger; auto error (false); // Open rocksdb database nano::rocksdb_config rocksdb_config; rocksdb_config.enable = true; - auto rocksdb_store = nano::make_store (nlogger, data_path_a, nano::dev::constants, false, true, rocksdb_config); + auto rocksdb_store = nano::make_store (logger, data_path_a, nano::dev::constants, false, true, rocksdb_config); if (!rocksdb_store->init_error ()) { diff --git a/nano/slow_test/entry.cpp b/nano/slow_test/entry.cpp index 5e3ff3ea5a..0b9a0ca758 100644 --- a/nano/slow_test/entry.cpp +++ b/nano/slow_test/entry.cpp @@ -14,7 +14,7 @@ void force_nano_dev_network (); int main (int argc, char ** argv) { - nano::nlogger::initialize_for_tests (nano::log_config::tests_default ()); + nano::logger::initialize_for_tests (nano::log_config::tests_default ()); nano::force_nano_dev_network (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; testing::InitGoogleTest (&argc, argv); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 141ae86cc7..4310968dae 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -117,7 +117,7 @@ TEST (system, receive_while_synchronizing) TEST (ledger, deep_account_compute) { - nano::nlogger logger; + nano::logger logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stats stats; @@ -537,7 +537,7 @@ TEST (store, vote_load) */ TEST (store, pruned_load) { - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); constexpr auto num_pruned = 2000000; auto const expected_result = num_pruned / 2; @@ -1223,7 +1223,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) // Don't test this in rocksdb mode return; } - nano::nlogger logger; + nano::logger logger; auto path (nano::unique_path ()); auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); diff --git a/nano/store/lmdb/lmdb.cpp b/nano/store/lmdb/lmdb.cpp index ccc5a4934c..4dd9e64407 100644 --- a/nano/store/lmdb/lmdb.cpp +++ b/nano/store/lmdb/lmdb.cpp @@ -12,7 +12,7 @@ #include -nano::store::lmdb::component::component (nano::nlogger & nlogger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : +nano::store::lmdb::component::component (nano::logger & logger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : // clang-format off nano::store::component{ block_store, @@ -37,9 +37,9 @@ nano::store::lmdb::component::component (nano::nlogger & nlogger_a, std::filesys confirmation_height_store{ *this }, final_vote_store{ *this }, version_store{ *this }, - nlogger{ nlogger_a }, + logger{ logger_a }, env (error, path_a, nano::store::lmdb::env::options::make ().set_config (lmdb_config_a).set_use_no_mem_init (true)), - mdb_txn_tracker (nlogger_a, txn_tracking_config_a, block_processor_batch_max_time_a), + mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a), txn_tracking_enabled (txn_tracking_config_a.enable) { if (!error) @@ -66,11 +66,11 @@ nano::store::lmdb::component::component (nano::nlogger & nlogger_a, std::filesys { if (!is_fresh_db) { - nlogger.info (nano::log::type::lmdb, "Upgrade in progress..."); + logger.info (nano::log::type::lmdb, "Upgrade in progress..."); if (backup_before_upgrade_a) { - create_backup_file (env, path_a, nlogger); + create_backup_file (env, path_a, logger); } } auto needs_vacuuming = false; @@ -85,17 +85,17 @@ nano::store::lmdb::component::component (nano::nlogger & nlogger_a, std::filesys if (needs_vacuuming) { - nlogger.info (nano::log::type::lmdb, "Ledger vaccum in progress..."); + logger.info (nano::log::type::lmdb, "Ledger vaccum in progress..."); auto vacuum_success = vacuum_after_upgrade (path_a, lmdb_config_a); if (vacuum_success) { - nlogger.info (nano::log::type::lmdb, "Ledger vacuum completed"); + logger.info (nano::log::type::lmdb, "Ledger vacuum completed"); } else { - nlogger.error (nano::log::type::lmdb, "Ledger vaccum failed"); - nlogger.error (nano::log::type::lmdb, "(Optional) Please ensure enough disk space is available for a copy of the database and try to vacuum after shutting down the node"); + logger.error (nano::log::type::lmdb, "Ledger vaccum failed"); + logger.error (nano::log::type::lmdb, "(Optional) Please ensure enough disk space is available for a copy of the database and try to vacuum after shutting down the node"); } } } @@ -212,7 +212,7 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans auto version_l = version.get (transaction_a); if (version_l < version_minimum) { - nlogger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); + logger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); return true; } switch (version_l) @@ -223,7 +223,7 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans case 22: break; default: - nlogger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is too high for this node", version_l); + logger.critical (nano::log::type::lmdb, "The version of the ledger ({}) is too high for this node", version_l); error = true; break; } @@ -232,18 +232,18 @@ bool nano::store::lmdb::component::do_upgrades (store::write_transaction & trans void nano::store::lmdb::component::upgrade_v21_to_v22 (store::write_transaction const & transaction_a) { - nlogger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22..."); + logger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22..."); MDB_dbi unchecked_handle{ 0 }; release_assert (!mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE, &unchecked_handle)); release_assert (!mdb_drop (env.tx (transaction_a), unchecked_handle, 1)); // del = 1, to delete it from the environment and close the DB handle. version.put (transaction_a, 22); - nlogger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22 completed"); + logger.info (nano::log::type::lmdb, "Upgrading database from v21 to v22 completed"); } /** Takes a filepath, appends '_backup_' to the end (but before any extension) and saves that file in the same directory */ -void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & env_a, std::filesystem::path const & filepath_a, nano::nlogger & nlogger) +void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & env_a, std::filesystem::path const & filepath_a, nano::logger & logger) { auto extension = filepath_a.extension (); auto filename_without_extension = filepath_a.filename ().replace_extension (""); @@ -255,17 +255,17 @@ void nano::store::lmdb::component::create_backup_file (nano::store::lmdb::env & backup_filename += extension; auto backup_filepath = backup_path / backup_filename; - nlogger.info (nano::log::type::lmdb, "Performing {} backup before database upgrade...", filepath_a.filename ().string ()); + logger.info (nano::log::type::lmdb, "Performing {} backup before database upgrade...", filepath_a.filename ().string ()); auto error (mdb_env_copy (env_a, backup_filepath.string ().c_str ())); if (error) { - nlogger.critical (nano::log::type::lmdb, "Database backup failed"); + logger.critical (nano::log::type::lmdb, "Database backup failed"); std::exit (1); } else { - nlogger.info (nano::log::type::lmdb, "Database backup completed. Backup can be found at: {}", backup_filepath.string ()); + logger.info (nano::log::type::lmdb, "Database backup completed. Backup can be found at: {}", backup_filepath.string ()); } } diff --git a/nano/store/lmdb/lmdb.hpp b/nano/store/lmdb/lmdb.hpp index 5b28dbdf11..a1f5dda6cf 100644 --- a/nano/store/lmdb/lmdb.hpp +++ b/nano/store/lmdb/lmdb.hpp @@ -63,7 +63,7 @@ class component : public nano::store::component friend class nano::store::lmdb::version; public: - component (nano::nlogger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); + component (nano::logger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); store::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; store::read_transaction tx_begin_read () const override; @@ -71,14 +71,14 @@ class component : public nano::store::component void serialize_mdb_tracker (boost::property_tree::ptree &, std::chrono::milliseconds, std::chrono::milliseconds) override; - static void create_backup_file (nano::store::lmdb::env &, std::filesystem::path const &, nano::nlogger &); + static void create_backup_file (nano::store::lmdb::env &, std::filesystem::path const &, nano::logger &); void serialize_memory_stats (boost::property_tree::ptree &) override; unsigned max_block_write_batch_num () const override; private: - nano::nlogger & nlogger; + nano::logger & logger; bool error{ false }; public: diff --git a/nano/store/lmdb/transaction.cpp b/nano/store/lmdb/transaction.cpp index c75fdc736c..2460539cfb 100644 --- a/nano/store/lmdb/transaction.cpp +++ b/nano/store/lmdb/transaction.cpp @@ -116,8 +116,8 @@ bool nano::store::lmdb::write_transaction_impl::contains (nano::tables table_a) return true; } -nano::mdb_txn_tracker::mdb_txn_tracker (nano::nlogger & nlogger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a) : - nlogger (nlogger_a), +nano::mdb_txn_tracker::mdb_txn_tracker (nano::logger & logger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a) : + logger (logger_a), txn_tracking_config (txn_tracking_config_a), block_processor_batch_max_time (block_processor_batch_max_time_a) { @@ -195,7 +195,7 @@ void nano::mdb_txn_tracker::log_if_held_long_enough (nano::mdb_txn_stats const & { debug_assert (mdb_txn_stats.stacktrace); - nlogger.warn (nano::log::type::txn_tracker, "{}ms {} held on thread {}\n{}", + logger.warn (nano::log::type::txn_tracker, "{}ms {} held on thread {}\n{}", time_open.count (), is_write ? "write lock" : "read", mdb_txn_stats.thread_name, diff --git a/nano/store/lmdb/transaction_impl.hpp b/nano/store/lmdb/transaction_impl.hpp index 971908b5da..06a4e1d414 100644 --- a/nano/store/lmdb/transaction_impl.hpp +++ b/nano/store/lmdb/transaction_impl.hpp @@ -72,7 +72,7 @@ class mdb_txn_stats class mdb_txn_tracker { public: - mdb_txn_tracker (nano::nlogger &, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a); + mdb_txn_tracker (nano::logger &, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a); void serialize_json (boost::property_tree::ptree & json, std::chrono::milliseconds min_read_time, std::chrono::milliseconds min_write_time); void add (store::transaction_impl const * transaction_impl); void erase (store::transaction_impl const * transaction_impl); @@ -80,7 +80,7 @@ class mdb_txn_tracker private: nano::mutex mutex; std::vector stats; - nano::nlogger & nlogger; + nano::logger & logger; nano::txn_tracking_config txn_tracking_config; std::chrono::milliseconds block_processor_batch_max_time; diff --git a/nano/store/rocksdb/rocksdb.cpp b/nano/store/rocksdb/rocksdb.cpp index a29e301311..099972583c 100644 --- a/nano/store/rocksdb/rocksdb.cpp +++ b/nano/store/rocksdb/rocksdb.cpp @@ -34,7 +34,7 @@ class event_listener : public rocksdb::EventListener }; } -nano::store::rocksdb::component::component (nano::nlogger & nlogger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : +nano::store::rocksdb::component::component (nano::logger & logger_a, std::filesystem::path const & path_a, nano::ledger_constants & constants, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : // clang-format off nano::store::component{ block_store, @@ -59,7 +59,7 @@ nano::store::rocksdb::component::component (nano::nlogger & nlogger_a, std::file confirmation_height_store{ *this }, final_vote_store{ *this }, version_store{ *this }, - nlogger{ nlogger_a }, + logger{ logger_a }, constants{ constants }, rocksdb_config{ rocksdb_config_a }, max_block_write_batch_num_m{ nano::narrow_cast (blocks_memtable_size_bytes () / (2 * (sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)))) }, @@ -95,14 +95,14 @@ nano::store::rocksdb::component::component (nano::nlogger & nlogger_a, std::file auto version_l = version.get (transaction); if (version_l > version_current) { - nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); + logger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); error = true; return; } else if (version_l < version_minimum) { - nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); + logger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is lower than the minimum ({}) which is supported for upgrades. Either upgrade a node first or delete the ledger.", version_l, version_minimum); error = true; return; @@ -151,7 +151,7 @@ nano::store::rocksdb::component::component (nano::nlogger & nlogger_a, std::file open (error, path_a, open_read_only_a, options, get_current_column_families (path_a.string (), options)); if (!error) { - nlogger.info (nano::log::type::rocksdb, "Upgrade in progress..."); + logger.info (nano::log::type::rocksdb, "Upgrade in progress..."); auto transaction = tx_begin_write (); error |= do_upgrades (transaction); @@ -243,7 +243,7 @@ bool nano::store::rocksdb::component::do_upgrades (store::write_transaction cons case 22: break; default: - nlogger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); + logger.critical (nano::log::type::rocksdb, "The version of the ledger ({}) is too high for this node", version_l); error_l = true; break; } @@ -252,7 +252,7 @@ bool nano::store::rocksdb::component::do_upgrades (store::write_transaction cons void nano::store::rocksdb::component::upgrade_v21_to_v22 (store::write_transaction const & transaction_a) { - nlogger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22..."); + logger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22..."); if (column_family_exists ("unchecked")) { @@ -268,12 +268,12 @@ void nano::store::rocksdb::component::upgrade_v21_to_v22 (store::write_transacti } return false; }); - nlogger.debug (nano::log::type::rocksdb, "Finished removing unchecked table"); + logger.debug (nano::log::type::rocksdb, "Finished removing unchecked table"); } version.put (transaction_a, 22); - nlogger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22 completed"); + logger.info (nano::log::type::rocksdb, "Upgrading database from v21 to v22 completed"); } void nano::store::rocksdb::component::generate_tombstone_map () @@ -916,7 +916,7 @@ bool nano::store::rocksdb::component::copy_db (std::filesystem::path const & des // Open it so that it flushes all WAL files if (status.ok ()) { - nano::store::rocksdb::component rocksdb_store{ nlogger, destination_path.string (), constants, rocksdb_config, false }; + nano::store::rocksdb::component rocksdb_store{ logger, destination_path.string (), constants, rocksdb_config, false }; return !rocksdb_store.init_error (); } return false; diff --git a/nano/store/rocksdb/rocksdb.hpp b/nano/store/rocksdb/rocksdb.hpp index 92a093504f..1c51bbbb05 100644 --- a/nano/store/rocksdb/rocksdb.hpp +++ b/nano/store/rocksdb/rocksdb.hpp @@ -64,7 +64,7 @@ class component : public nano::store::component friend class nano::store::rocksdb::pruned; friend class nano::store::rocksdb::version; - explicit component (nano::nlogger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); + explicit component (nano::logger &, std::filesystem::path const &, nano::ledger_constants & constants, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); store::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; store::read_transaction tx_begin_read () const override; @@ -103,7 +103,7 @@ class component : public nano::store::component private: bool error{ false }; - nano::nlogger & nlogger; + nano::logger & logger; nano::ledger_constants & constants; // Optimistic transactions are used in write mode ::rocksdb::OptimisticTransactionDB * optimistic_db = nullptr; diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index 7755ebaa7a..a3337bc925 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -3,7 +3,7 @@ #include nano::test::context::ledger_context::ledger_context (std::deque> && blocks) : - store_m{ nano::make_store (nlogger, nano::unique_path (), nano::dev::constants) }, + store_m{ nano::make_store (logger, nano::unique_path (), nano::dev::constants) }, ledger_m{ *store_m, stats_m, nano::dev::constants }, blocks_m{ blocks } { diff --git a/nano/test_common/ledger.hpp b/nano/test_common/ledger.hpp index 09c5d1bfa4..6b12c258a2 100644 --- a/nano/test_common/ledger.hpp +++ b/nano/test_common/ledger.hpp @@ -25,7 +25,7 @@ namespace test std::deque> const & blocks () const; private: - nano::nlogger nlogger; + nano::logger logger; std::unique_ptr store_m; nano::stats stats_m; nano::ledger ledger_m; diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index 278492edf4..8bff408828 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -67,7 +67,7 @@ namespace test boost::asio::io_context io_ctx; std::vector> nodes; nano::stats stats; - nano::nlogger nlogger; + nano::logger logger; nano::work_pool work{ nano::dev::network_params.network, std::max (nano::hardware_concurrency (), 1u) }; std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; double deadline_scaling_factor{ 1.0 }; From 81c598b00186bc85e961756943cb43b47e7eecf3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 20 Jan 2024 15:16:38 +0100 Subject: [PATCH 019/190] Remove leftover boost::log reference --- nano/store/CMakeLists.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt index 427e038082..fc5e6b6010 100644 --- a/nano/store/CMakeLists.txt +++ b/nano/store/CMakeLists.txt @@ -100,8 +100,6 @@ target_link_libraries( Boost::circular_buffer Boost::endian Boost::iostreams - Boost::log_setup - Boost::log Boost::multiprecision Boost::pool Boost::stacktrace From a97cbff2c009a2f9e9ea1ea70c87b204d79d09c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 20 Jan 2024 15:18:10 +0100 Subject: [PATCH 020/190] Missing `nano_lib` link --- nano/store/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt index fc5e6b6010..a992ba59bc 100644 --- a/nano/store/CMakeLists.txt +++ b/nano/store/CMakeLists.txt @@ -97,6 +97,7 @@ add_library( target_link_libraries( nano_store + nano_lib Boost::circular_buffer Boost::endian Boost::iostreams From cef74b94603e62bc4aa9c5de48e895bb81c59fae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 21 Jan 2024 16:21:34 +0100 Subject: [PATCH 021/190] Fix deserialization of config with default values --- nano/core_test/toml.cpp | 89 +++++++++++++++++++++++++++++++++++++++++ nano/lib/logging.cpp | 12 +++--- 2 files changed, 95 insertions(+), 6 deletions(-) diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index 5c0d83b3b6..b28c875750 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -917,3 +917,92 @@ TEST (toml, tls_config_defaults) ASSERT_EQ (conf.server_key_passphrase, defaults.server_key_passphrase); ASSERT_EQ (conf.server_dh_path, defaults.server_dh_path); } + +TEST (toml, log_config_defaults) +{ + std::stringstream ss; + + // A config with no values + ss << R"toml()toml"; + + nano::tomlconfig toml; + toml.read (ss); + nano::log_config confg{}; + nano::log_config defaults{}; + confg.deserialize_toml (toml); + + ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); + + ASSERT_EQ (confg.default_level, defaults.default_level); + ASSERT_EQ (confg.flush_level, defaults.flush_level); + ASSERT_EQ (confg.levels, defaults.levels); + ASSERT_EQ (confg.console.enable, defaults.console.enable); + ASSERT_EQ (confg.console.colors, defaults.console.colors); + ASSERT_EQ (confg.console.to_cerr, defaults.console.to_cerr); + ASSERT_EQ (confg.file.enable, defaults.file.enable); + ASSERT_EQ (confg.file.max_size, defaults.file.max_size); + ASSERT_EQ (confg.file.rotation_count, defaults.file.rotation_count); +} + +TEST (toml, log_config_no_defaults) +{ + std::stringstream ss; + + // A config file with values that differs from defaults + ss << R"toml( + [log] + default_level = "trace" + + [log.console] + colors = false + enable = false + to_cerr = true + + [log.file] + enable = false + max_size = 999 + rotation_count = 999 + + [log.levels] + active_transactions = "trace" + blockprocessor = "trace" + )toml"; + + nano::tomlconfig toml; + toml.read (ss); + nano::log_config confg{}; + nano::log_config defaults{}; + confg.deserialize_toml (toml); + + ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); + + ASSERT_NE (confg.default_level, defaults.default_level); + ASSERT_NE (confg.levels, defaults.levels); + ASSERT_NE (confg.console.enable, defaults.console.enable); + ASSERT_NE (confg.console.colors, defaults.console.colors); + ASSERT_NE (confg.console.to_cerr, defaults.console.to_cerr); + ASSERT_NE (confg.file.enable, defaults.file.enable); + ASSERT_NE (confg.file.max_size, defaults.file.max_size); + ASSERT_NE (confg.file.rotation_count, defaults.file.rotation_count); +} + +TEST (toml, log_config_no_required) +{ + std::stringstream ss; + + // A config with no values, only categories + ss << R"toml( + [log] + [log.console] + [log.file] + [log.levels] + )toml"; + + nano::tomlconfig toml; + toml.read (ss); + nano::log_config confg{}; + nano::log_config defaults{}; + confg.deserialize_toml (toml); + + ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); +} \ No newline at end of file diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index f24c2e8ed8..ce87050e52 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -368,17 +368,17 @@ void nano::log_config::deserialize (nano::tomlconfig & toml) if (toml.has_key ("console")) { auto console_config = toml.get_required_child ("console"); - console.enable = console_config.get ("enable"); - console.to_cerr = console_config.get ("to_cerr"); - console.colors = console_config.get ("colors"); + console_config.get ("enable", console.enable); + console_config.get ("to_cerr", console.to_cerr); + console_config.get ("colors", console.colors); } if (toml.has_key ("file")) { auto file_config = toml.get_required_child ("file"); - file.enable = file_config.get ("enable"); - file.max_size = file_config.get ("max_size"); - file.rotation_count = file_config.get ("rotation_count"); + file_config.get ("enable", file.enable); + file_config.get ("max_size", file.max_size); + file_config.get ("rotation_count", file.rotation_count); } if (toml.has_key ("levels")) From a04f0789a3253d6dc37733973ee227abbe826971 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Sun, 21 Jan 2024 19:32:28 +0100 Subject: [PATCH 022/190] Assert conversions part 2 (#4376) --- nano/core_test/node.cpp | 6 +++--- nano/core_test/socket.cpp | 6 +++--- nano/core_test/uint256_union.cpp | 4 ++-- nano/rpc_test/rpc.cpp | 2 +- nano/slow_test/vote_processor.cpp | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 239d29d300..dcf7219486 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -25,7 +25,7 @@ TEST (node, null_account) nano::account default_account{}; ASSERT_FALSE (default_account == nullptr); - ASSERT_TRUE (default_account != nullptr); + ASSERT_NE (default_account, nullptr); } TEST (node, stop) @@ -47,7 +47,7 @@ TEST (node, work_generate) auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base); auto work = node.work_generate_blocking (version, root, difficulty); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); } { auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base); @@ -57,7 +57,7 @@ TEST (node, work_generate) work = node.work_generate_blocking (version, root, difficulty); } while (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); } } diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index 02a19e9c56..d4b7f14448 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -115,7 +115,7 @@ TEST (socket, max_connections_per_ip) auto server_port = system.get_available_port (); const auto max_ip_connections = node->network_params.network.max_peers_per_ip; - ASSERT_TRUE (max_ip_connections >= 1); + ASSERT_GE (max_ip_connections, 1); const auto max_global_connections = 1000; @@ -235,7 +235,7 @@ TEST (socket, max_connections_per_subnetwork) boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; const auto max_subnetwork_connections = node->network_params.network.max_peers_per_subnetwork; - ASSERT_TRUE (max_subnetwork_connections >= 1); + ASSERT_GE (max_subnetwork_connections, 1); const auto max_global_connections = 1000; @@ -295,7 +295,7 @@ TEST (socket, disabled_max_peers_per_ip) auto server_port = system.get_available_port (); const auto max_ip_connections = node->network_params.network.max_peers_per_ip; - ASSERT_TRUE (max_ip_connections >= 1); + ASSERT_GE (max_ip_connections, 1); const auto max_global_connections = 1000; diff --git a/nano/core_test/uint256_union.cpp b/nano/core_test/uint256_union.cpp index c85c612704..86c82f6609 100644 --- a/nano/core_test/uint256_union.cpp +++ b/nano/core_test/uint256_union.cpp @@ -614,7 +614,7 @@ TEST (random_pool, generate_word64) for (auto i = 1; i < 10; ++i) { - ASSERT_TRUE (occurrences[i] > 0); + ASSERT_GT (occurrences[i], 0); } } @@ -624,5 +624,5 @@ TEST (random_pool, generate_word64_big_number) uint64_t min = static_cast (std::numeric_limits::max ()) + 1; uint64_t max = std::numeric_limits::max (); auto big_random = nano::random_pool::generate_word64 (min, max); - ASSERT_TRUE (big_random >= min); + ASSERT_GE (big_random, min); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 056d05a1b7..f8bba8ae02 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -6617,7 +6617,7 @@ TEST (rpc, receive_work_disabled) nano::keypair key1; ASSERT_TRUE (worker_node.work_generation_enabled ()); auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *worker_node.work_generate_blocking (nano::dev::genesis->hash ()), false)); - ASSERT_TRUE (send1 != nullptr); + ASSERT_NE (send1, nullptr); ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub)); ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ())); diff --git a/nano/slow_test/vote_processor.cpp b/nano/slow_test/vote_processor.cpp index eaae35577d..ff1ae1f52d 100644 --- a/nano/slow_test/vote_processor.cpp +++ b/nano/slow_test/vote_processor.cpp @@ -75,5 +75,5 @@ TEST (vote_processor, producer_consumer) consumer_thread.join (); monitor_thread.join (); - ASSERT_TRUE (producer_wins > consumer_wins); + ASSERT_GT (producer_wins, consumer_wins); } From 815ac36ae2c0184b7bd364c8cec7426d89a7896e Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 22 Jan 2024 16:07:36 +0700 Subject: [PATCH 023/190] Fix for node.fork_publish_inactive (#4382) By taking a copy of blocks and saving it into a variable we are not giving a chance to the ASSET_TIMELY to work if the result is not immediately correct. --- nano/core_test/node.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index dcf7219486..a6f3e16928 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -644,10 +644,15 @@ TEST (node, fork_publish_inactive) ASSERT_EQ (nano::process_result::fork, node.process_local (send2).value ().code); - auto blocks = election->blocks (); - ASSERT_TIMELY_EQ (5s, blocks.size (), 2); - ASSERT_NE (blocks.end (), blocks.find (send1->hash ())); - ASSERT_NE (blocks.end (), blocks.find (send2->hash ())); + ASSERT_TIMELY_EQ (5s, election->blocks ().size (), 2); + + auto find_block = [&election] (nano::block_hash hash_a) -> bool { + auto blocks = election->blocks (); + return blocks.end () != blocks.find (hash_a); + }; + ASSERT_TRUE (find_block (send1->hash ())); + ASSERT_TRUE (find_block (send2->hash ())); + ASSERT_EQ (election->winner ()->hash (), send1->hash ()); ASSERT_NE (election->winner ()->hash (), send2->hash ()); } From 06d8b4e7ba20af559e1175fc91b396c417608c71 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 22 Jan 2024 20:28:24 +0700 Subject: [PATCH 024/190] Fixing a race condition in active_transactions.fork_replacement_tally (#4385) I did not check the unit test, just fixing the race condition I see because the CI failed on the assert where it couldn't find the election. The election finding needs to be inside an ASSERT_TIMELY. --- nano/core_test/active_transactions.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 3ed7f1f5e7..89623eabc0 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -898,11 +898,10 @@ TEST (active_transactions, fork_replacement_tally) .build_shared (); node1.process_active (fork); } - ASSERT_TIMELY (5s, !node1.active.empty ()); // Check overflow of blocks - auto election = node1.active.election (send_last->qualified_root ()); - ASSERT_NE (nullptr, election); + std::shared_ptr election; + ASSERT_TIMELY (5s, election = node1.active.election (send_last->qualified_root ())); ASSERT_TIMELY_EQ (5s, max_blocks, election->blocks ().size ()); // Generate forks with votes to prevent new block insertion to election From b4eb3a0637f80a56efbbf77d24d90eb7305f3697 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:22:00 +0100 Subject: [PATCH 025/190] Fixes & comments --- nano/lib/config.cpp | 5 +++-- nano/lib/config.hpp | 8 ++++++-- nano/lib/logging.cpp | 41 +++++++++++++++++++++---------------- nano/lib/logging.hpp | 21 ++++++++++--------- nano/test_common/system.hpp | 2 +- 5 files changed, 44 insertions(+), 33 deletions(-) diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index d8b3a60d74..7f40e3b039 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -377,6 +377,7 @@ std::string_view nano::to_string (nano::networks network) return "n/a"; } +// Using std::cerr here, since logging may not be initialized yet nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides) { std::stringstream config_overrides_stream; @@ -396,7 +397,7 @@ nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_file { throw std::runtime_error (error.get_message ()); } - nano::default_logger ().info (nano::log::type::config, "Config for `{}` loaded from node data directory: ", config_filename.string (), toml_config_path.string ()); + std::cerr << "Config file `" << config_filename.string () << "` loaded from node data directory: " << toml_config_path.string () << std::endl; return toml; } else @@ -408,7 +409,7 @@ nano::tomlconfig nano::load_toml_file (const std::filesystem::path & config_file { throw std::runtime_error (error.get_message ()); } - nano::default_logger ().info (nano::log::type::config, "Config for `{}` not found, using default configuration", config_filename.string ()); + std::cerr << "Config file `" << config_filename.string () << "` not found, using default configuration" << std::endl; return toml; } } diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index d319d0aff5..5db3296c78 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -410,11 +410,15 @@ bool is_sanitizer_build (); void force_nano_dev_network (); /** - * Attempt to read a configuration file from current working directory, or if not found, the nano root directory. - * Returns empty tomlconfig if nothing is found. + * Attempt to read a configuration file from specified directory. Returns empty tomlconfig if nothing is found. + * @throws std::runtime_error with error code if the file or overrides are not valid toml */ nano::tomlconfig load_toml_file (const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides); +/** + * Attempt to read a configuration file from specified directory. Returns fallback config if nothing is found. + * @throws std::runtime_error with error code if the file or overrides are not valid toml or deserialization fails + */ template T load_config_file (T fallback, const std::filesystem::path & config_filename, const std::filesystem::path & data_path, const std::vector & config_overrides) { diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index ce87050e52..8e9062288d 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -3,18 +3,12 @@ #include #include -#include #include #include #include #include #include -namespace -{ -std::atomic logging_initialized{ false }; -} - nano::logger & nano::default_logger () { static nano::logger logger{ "default" }; @@ -34,9 +28,10 @@ std::function nano::l return std::string{ to_string (tag) }; } }; -void nano::logger::initialize (nano::log_config fallback, std::filesystem::path data_path, std::vector const & config_overrides) +void nano::logger::initialize (nano::log_config fallback, std::optional data_path, std::vector const & config_overrides) { - auto config = nano::load_log_config (std::move (fallback), data_path, config_overrides); + // Only load log config from file if data_path is available (i.e. not running in cli mode) + nano::log_config config = data_path ? nano::load_log_config (fallback, *data_path, config_overrides) : fallback; initialize_common (config, data_path); global_initialized = true; } @@ -97,8 +92,8 @@ class tag_formatter_flag : public spdlog::custom_flag_formatter void nano::logger::initialize_for_tests (nano::log_config fallback) { - auto config = nano::load_log_config (std::move (fallback), /* load log config from current workdir */ {}); - initialize_common (config, /* store log file in current workdir */ {}); + auto config = nano::load_log_config (std::move (fallback), /* load log config from current workdir */ std::filesystem::current_path ()); + initialize_common (config, /* store log file in current workdir */ std::filesystem::current_path ()); // Use tag and identifier as the logger name, since multiple nodes may be running in the same process global_name_formatter = [] (nano::log::type tag, std::string identifier) { @@ -119,13 +114,13 @@ void nano::logger::initialize_for_tests (nano::log_config fallback) global_initialized = true; } -void nano::logger::initialize_common (nano::log_config const & config, std::filesystem::path data_path) +// Using std::cerr here, since logging may not be initialized yet +void nano::logger::initialize_common (nano::log_config const & config, std::optional data_path) { global_config = config; spdlog::set_automatic_registration (false); spdlog::set_level (to_spdlog_level (config.default_level)); - spdlog::cfg::load_env_levels (); global_sinks.clear (); @@ -156,13 +151,16 @@ void nano::logger::initialize_common (nano::log_config const & config, std::file // File setup if (config.file.enable) { + // In cases where data_path is not available, file logging should always be disabled + release_assert (data_path); + auto now = std::chrono::system_clock::now (); auto time = std::chrono::system_clock::to_time_t (now); auto filename = fmt::format ("log_{:%Y-%m-%d_%H-%M}-{:%S}", fmt::localtime (time), now.time_since_epoch ()); std::replace (filename.begin (), filename.end (), '.', '_'); // Replace millisecond dot separator with underscore - std::filesystem::path log_path{ data_path / "log" / (filename + ".log") }; + std::filesystem::path log_path{ data_path.value () / "log" / (filename + ".log") }; log_path = std::filesystem::absolute (log_path); std::cerr << "Logging to file: " << log_path.string () << std::endl; @@ -170,7 +168,7 @@ void nano::logger::initialize_common (nano::log_config const & config, std::file // If either max_size or rotation_count is 0, then disable file rotation if (config.file.max_size == 0 || config.file.rotation_count == 0) { - // TODO: Maybe show a warning to the user about possibly unlimited log file size + std::cerr << "WARNING: Log file rotation is disabled, log file size may grow without bound" << std::endl; auto file_sink = std::make_shared (log_path.string (), true); global_sinks.push_back (file_sink); @@ -198,13 +196,19 @@ void nano::logger::flush () nano::logger::logger (std::string identifier) : identifier{ std::move (identifier) } { + release_assert (global_initialized, "logging should be initialized before creating a logger"); +} + +nano::logger::~logger () +{ + flush (); } spdlog::logger & nano::logger::get_logger (nano::log::type tag) { // This is a two-step process to avoid exclusively locking the mutex in the common case { - std::shared_lock slock{ mutex }; + std::shared_lock lock{ mutex }; if (auto it = spd_loggers.find (tag); it != spd_loggers.end ()) { @@ -215,8 +219,8 @@ spdlog::logger & nano::logger::get_logger (nano::log::type tag) { std::unique_lock lock{ mutex }; - auto [it2, inserted] = spd_loggers.emplace (tag, make_logger (tag)); - return *it2->second; + auto [it, inserted] = spd_loggers.emplace (tag, make_logger (tag)); + return *it->second; } } @@ -242,7 +246,7 @@ std::shared_ptr nano::logger::make_logger (nano::log::type tag) return spd_logger; } -spdlog::level::level_enum nano::to_spdlog_level (nano::log::level level) +spdlog::level::level_enum nano::logger::to_spdlog_level (nano::log::level level) { switch (level) { @@ -437,6 +441,7 @@ std::map nano::log_config::defa * config loading */ +// Using std::cerr here, since logging may not be initialized yet nano::log_config nano::load_log_config (nano::log_config fallback, const std::filesystem::path & data_path, const std::vector & config_overrides) { const std::string config_filename = "config-log.toml"; diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 4844cda40b..55f08ad64f 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -59,24 +59,19 @@ class log_config final static std::map default_levels (nano::log::level); }; -/// @throws std::runtime_error if the log config file is malformed -nano::log_config load_log_config (nano::log_config fallback, std::filesystem::path const & data_path = {}, std::vector const & config_overrides = std::vector ()); -} - -namespace nano -{ -spdlog::level::level_enum to_spdlog_level (nano::log::level); +nano::log_config load_log_config (nano::log_config fallback, std::filesystem::path const & data_path, std::vector const & config_overrides = {}); class logger final { public: - logger (std::string identifier = ""); + explicit logger (std::string identifier = ""); + ~logger (); // Disallow copies logger (logger const &) = delete; public: - static void initialize (nano::log_config fallback, std::filesystem::path data_path = {}, std::vector const & config_overrides = std::vector ()); + static void initialize (nano::log_config fallback, std::optional data_path = std::nullopt, std::vector const & config_overrides = std::vector ()); static void initialize_for_tests (nano::log_config fallback); static void flush (); @@ -86,7 +81,7 @@ class logger final static std::vector global_sinks; static std::function global_name_formatter; - static void initialize_common (nano::log_config const &, std::filesystem::path data_path); + static void initialize_common (nano::log_config const &, std::optional data_path); public: template @@ -134,7 +129,13 @@ class logger final private: spdlog::logger & get_logger (nano::log::type tag); std::shared_ptr make_logger (nano::log::type tag); + + static spdlog::level::level_enum to_spdlog_level (nano::log::level); }; +/** + * Returns a logger instance that can be used before node specific logging is available. + * Should only be used for logging that happens during startup and initialization, since it won't contain node specific identifier. + */ nano::logger & default_logger (); } \ No newline at end of file diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index 8bff408828..8e0cf19bc3 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -67,7 +67,7 @@ namespace test boost::asio::io_context io_ctx; std::vector> nodes; nano::stats stats; - nano::logger logger; + nano::logger logger{ "tests" }; nano::work_pool work{ nano::dev::network_params.network, std::max (nano::hardware_concurrency (), 1u) }; std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; double deadline_scaling_factor{ 1.0 }; From 7e58c50140921031ebb1f59a7fc8a3594ec6022b Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Tue, 23 Jan 2024 09:47:43 +0700 Subject: [PATCH 026/190] Fix rpc receivable unconfirmed and rpc.accounts_receivable_confirmed (#4387) * Fix rpc.receivable_unconfirmed In RPC speak, cofnirmed is equivalent to cemented and in this case the test only check if the election is not active, which indirectly but not directly implies that the election is confirmed. But even then it is not necesarily cemented since that is an extra background step. We should check for cemented with the function nano::test:confirmed(), which is also confusing... * Also fix rpc.accounts_receivable_confirmed --- nano/rpc_test/receivable.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 61dd352d35..09d7816dbe 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -146,7 +146,7 @@ TEST (rpc, receivable_unconfirmed) request.put ("include_only_confirmed", "false"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); ASSERT_TRUE (nano::test::start_elections (system, *node, { block1->hash () }, true)); - ASSERT_TIMELY (5s, !node->active.active (*block1)); + ASSERT_TIMELY (5s, nano::test::confirmed (*node, { block1 })); request.put ("include_only_confirmed", "true"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); } @@ -533,7 +533,6 @@ TEST (rpc, accounts_receivable_confirmed) auto node = add_ipc_enabled_node (system, config); auto chain = nano::test::setup_chain (system, *node, 1, nano::dev::genesis_key, false); auto block1 = chain[0]; - ASSERT_TIMELY (5s, !node->active.active (*block1)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -550,7 +549,7 @@ TEST (rpc, accounts_receivable_confirmed) request.put ("include_only_confirmed", "false"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); ASSERT_TRUE (nano::test::start_elections (system, *node, { block1->hash () }, true)); - ASSERT_TIMELY (5s, !node->active.active (*block1)); + ASSERT_TIMELY (5s, nano::test::confirmed (*node, { block1 })); request.put ("include_only_confirmed", "true"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); } From 81e6b5747cb398439be5049757e4b63d09d3d006 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 23 Jan 2024 18:45:06 +0100 Subject: [PATCH 027/190] Warning about using cerr with colors --- nano/lib/logging.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 8e9062288d..4147ea5a3e 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -143,6 +143,11 @@ void nano::logger::initialize_common (nano::log_config const & config, std::opti } else { + if (config.console.colors) + { + std::cerr << "WARNING: Logging to cerr is enabled, console colors will be disabled" << std::endl; + } + auto cerr_sink = std::make_shared (); global_sinks.push_back (cerr_sink); } From 92ef79ed54e50a4db8594649ff0afc308401da95 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 24 Jan 2024 15:12:25 +0000 Subject: [PATCH 028/190] Applying [[noreturn]] attribute to asset_internal (#4392) This will silence warnings/errors in functions that don't return values in control flow paths that end with release_assert. "warning: non-void function does not return a value in all control paths [-Wreturn-type]" --- nano/lib/utility.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 331c0534ab..72ea310dae 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -29,7 +29,7 @@ namespace program_options } } -void assert_internal (char const * check_expr, char const * func, char const * file, unsigned int line, bool is_release_assert, std::string_view error = ""); +[[noreturn]] void assert_internal (char const * check_expr, char const * func, char const * file, unsigned int line, bool is_release_assert, std::string_view error = ""); #define release_assert_1(check) check ? (void)0 : assert_internal (#check, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, true) #define release_assert_2(check, error_msg) check ? (void)0 : assert_internal (#check, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, true, error_msg) From afcbde1928e8b9d3fba48062669c0f16f71bc655 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Wed, 24 Jan 2024 23:52:17 +0100 Subject: [PATCH 029/190] Convenience function for block_or_pruned_exists (#4393) Convenience function for block_or_pruned_exists --- nano/core_test/bootstrap.cpp | 34 ++++++++-------------------------- nano/core_test/node.cpp | 18 +++++------------- nano/rpc_test/rpc.cpp | 3 +-- nano/test_common/testutil.cpp | 28 ++++++++++++++++++++++++++++ nano/test_common/testutil.hpp | 20 ++++++++++++++++++++ 5 files changed, 62 insertions(+), 41 deletions(-) diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 10198e45de..ba55acd741 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -1126,10 +1126,7 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) node2->bootstrap_initiator.bootstrap_lazy (receive->hash ()); // Check processed blocks ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (receive->hash ())); + ASSERT_TIMELY (5s, nano::test::block_or_pruned_all_exists (*node2, { send1, send2, open, receive })); ASSERT_EQ (0, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); } @@ -1185,9 +1182,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks ASSERT_TIMELY (15s, !node2->bootstrap_initiator.in_progress ()); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_TIMELY (15s, nano::test::block_or_pruned_all_exists (*node2, { send1, open, send2 })); ASSERT_EQ (1, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); } @@ -1254,10 +1249,7 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (state_open->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2, open, state_open })); } TEST (bootstrap_processor, lazy_pruning_missing_block) @@ -1329,10 +1321,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) node1->ledger_pruning (2, false); ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (1, node1->ledger.cache.pruned_count); - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send1->hash ())); // true for pruned - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (state_open->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node1, { send1, send2, open, state_open })); // Start lazy bootstrap with last block in sender chain config.peering_port = system.get_available_port (); auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); @@ -1345,10 +1334,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) // Some blocks cannot be retrieved from pruned node node2->block_processor.flush (); ASSERT_EQ (1, node2->ledger.cache.block_count); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (state_open->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_none_exists (*node2, { send1, send2, open, state_open })); { auto transaction (node2->store.tx_begin_read ()); ASSERT_TRUE (node2->unchecked.exists (nano::unchecked_key (send2->root ().as_block_hash (), send2->hash ()))); @@ -1359,10 +1345,8 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) ASSERT_TIMELY (5s, !node2->bootstrap_initiator.in_progress ()); node2->block_processor.flush (); ASSERT_EQ (3, node2->ledger.cache.block_count); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (open->hash ())); - ASSERT_FALSE (node2->ledger.block_or_pruned_exists (state_open->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2 })); + ASSERT_TRUE (nano::test::block_or_pruned_none_exists (*node2, { open, state_open })); node2->stop (); } @@ -2034,9 +2018,7 @@ TEST (bulk, DISABLED_genesis_pruning) node1->ledger_pruning (2, false); ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (4, node1->ledger.cache.block_count); - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send1->hash ())); // true for pruned - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send2->hash ())); // true for pruned - ASSERT_TRUE (node1->ledger.block_or_pruned_exists (send3->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2, send3 })); // Bootstrap with missing blocks for node2 node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); node2->network.merge_peer (node1->network.endpoint ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index c5b5faa218..a0d9e63d2f 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -816,16 +816,14 @@ TEST (node, fork_multi_flip) ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish2.block->hash ())); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish3.block->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (node2, { publish2.block, publish3.block })); ASSERT_TIMELY (10s, node2.ledger.block_or_pruned_exists (publish1.block->hash ())); auto winner (*election1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish1.block->hash ())); - ASSERT_FALSE (node2.ledger.block_or_pruned_exists (publish2.block->hash ())); - ASSERT_FALSE (node2.ledger.block_or_pruned_exists (publish3.block->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_none_exists (node2, { publish2.block, publish3.block })); } // Blocks that are no longer actively being voted on should be able to be evicted through bootstrapping. @@ -4180,9 +4178,7 @@ TEST (node, pruning_automatic) ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (node1, { nano::dev::genesis, send1, send2 })); } TEST (node, pruning_age) @@ -4241,9 +4237,7 @@ TEST (node, pruning_age) ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (node1, { nano::dev::genesis, send1, send2 })); } // Test that a node configured with `enable_pruning` will @@ -4304,9 +4298,7 @@ TEST (node, pruning_depth) ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_all_exists (node1, { nano::dev::genesis, send1, send2 })); } TEST (node_config, node_id_private_key_persistence) diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index c7b95d71d6..166f5e6cc9 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -6502,8 +6502,7 @@ TEST (rpc, account_lazy_start) // needs timed assert because the writing (put) operation is done by a different // thread, it might not get done before DB get operation. - ASSERT_TIMELY (10s, node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_TIMELY (10s, node2->ledger.block_or_pruned_exists (open->hash ())); + ASSERT_TIMELY (15s, nano::test::block_or_pruned_all_exists (*node2, { send1, open })); } TEST (rpc, receive) diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 56d89419f1..68b6e7ee92 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -115,6 +115,34 @@ bool nano::test::exists (nano::node & node, std::vector hashes) +{ + auto transaction = node.store.tx_begin_read (); + return std::all_of (hashes.begin (), hashes.end (), + [&] (const auto & hash) { + return node.ledger.block_or_pruned_exists (transaction, hash); + }); +} + +bool nano::test::block_or_pruned_all_exists (nano::node & node, std::vector> blocks) +{ + return block_or_pruned_all_exists (node, blocks_to_hashes (blocks)); +} + +bool nano::test::block_or_pruned_none_exists (nano::node & node, std::vector hashes) +{ + auto transaction = node.store.tx_begin_read (); + return std::none_of (hashes.begin (), hashes.end (), + [&] (const auto & hash) { + return node.ledger.block_or_pruned_exists (transaction, hash); + }); +} + +bool nano::test::block_or_pruned_none_exists (nano::node & node, std::vector> blocks) +{ + return block_or_pruned_none_exists (node, blocks_to_hashes (blocks)); +} + bool nano::test::activate (nano::node & node, std::vector hashes) { for (auto & hash : hashes) diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index 766d6da64d..3696d8791a 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -300,6 +300,26 @@ namespace test * @return true if all blocks are fully processed and inserted in the ledger, false otherwise */ bool exists (nano::node & node, std::vector> blocks); + /* + * Convenience function to check whether *all* of the hashes exists in node ledger or in the pruned table. + * @return true if all blocks are fully processed and inserted in the ledger, false otherwise + */ + bool block_or_pruned_all_exists (nano::node & node, std::vector hashes); + /* + * Convenience function to check whether *all* of the blocks exists in node ledger or their hash exists in the pruned table. + * @return true if all blocks are fully processed and inserted in the ledger, false otherwise + */ + bool block_or_pruned_all_exists (nano::node & node, std::vector> blocks); + /* + * Convenience function to check whether *none* of the hashes exists in node ledger or in the pruned table. + * @return true if none of the blocks are processed and inserted in the ledger, false otherwise + */ + bool block_or_pruned_none_exists (nano::node & node, std::vector hashes); + /* + * Convenience function to check whether *none* of the blocks exists in node ledger or their hash exists in the pruned table. + * @return true if none of the blocks are processed and inserted in the ledger, false otherwise + */ + bool block_or_pruned_none_exists (nano::node & node, std::vector> blocks); /* * Convenience function to start elections for a list of hashes. Blocks are loaded from ledger. * @return true if all blocks exist and were queued to election scheduler From 6f996b23fe317fa851d18d901b76b504754cfaa4 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 25 Jan 2024 18:45:39 +0700 Subject: [PATCH 030/190] Some helpful comments about unit test socket_timeout.connect (#4389) --- nano/core_test/socket.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index d4b7f14448..eaa31f761b 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -572,6 +572,11 @@ TEST (socket, concurrent_writes) * set timeout to one second * do a tcp connect that will block for at least a few seconds at the tcp level * check that the connect returns error and that the correct counters have been incremented + * + * NOTE: it is possible that the O/S has tried to access the IP address 10.255.254.253 before + * and has it marked in the routing table as unroutable. In that case this test case will fail. + * If this test is run repeadetly the tests fails for this reason because the connection fails + * with "No route to host" error instead of a timeout. */ TEST (socket_timeout, connect) { @@ -603,6 +608,8 @@ TEST (socket_timeout, connect) ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_connect_error, nano::stat::dir::in)); // check that the socket was closed due to tcp_io_timeout timeout + // NOTE: this assert is not guaranteed to be always true, it is only likely that it will be true, we can also get "No route to host" + // if this test is run repeatedly or in parallel then it is guaranteed to fail due to "No route to host" instead of timeout ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_io_timeout_drop, nano::stat::dir::out)); } From 4fbae94bb785bc9065c090b6a42dc6b5b741a1e3 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 25 Jan 2024 19:42:20 +0700 Subject: [PATCH 031/190] Fix active_transactions.confirm_frontier (#4386) The main problem was that the bootstrap processes could sync the block before the test tried to insert it and it woudl fail because the block was already there. The main problem I fixed was to disable the bootstrap processes. I also improved it overall and made it more readable. --- nano/core_test/active_transactions.cpp | 62 ++++++++++++++++---------- 1 file changed, 38 insertions(+), 24 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 89623eabc0..42644411e7 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -104,17 +104,43 @@ namespace nano TEST (active_transactions, confirm_frontier) { nano::test::system system; - nano::node_flags node_flags; - node_flags.disable_request_loop = true; - // Voting node - auto & node1 = *system.add_node (node_flags); - nano::node_flags node_flags2; + + // send 100 raw from genesis to a random account + nano::state_block_builder builder; + auto send = builder + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .link (nano::public_key ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build_shared (); + + { + // Voting node + nano::node_flags node_flags; + node_flags.disable_request_loop = true; + node_flags.disable_ongoing_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + auto & node1 = *system.add_node (node_flags); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + + // we cannot use the same block instance on 2 different nodes, so make a copy + auto send_copy = builder.make_block ().from (*send).build_shared (); + ASSERT_TRUE (nano::test::process (node1, { send_copy })); + ASSERT_TRUE (nano::test::start_elections (system, node1, { send_copy })); + ASSERT_TIMELY (5s, nano::test::confirmed (node1, { send_copy })); + } + // The rep crawler would otherwise request confirmations in order to find representatives + nano::node_flags node_flags2; + node_flags2.disable_ongoing_bootstrap = true; + node_flags2.disable_ascending_bootstrap = true; node_flags2.disable_rep_crawler = true; + // start node2 later so that we do not get the gossip traffic auto & node2 = *system.add_node (node_flags2); - // Add key to node1 - system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Add representative to disabled rep crawler auto peers (node2.network.random_set (1)); ASSERT_FALSE (peers.empty ()); @@ -123,25 +149,13 @@ TEST (active_transactions, confirm_frontier) node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); } - nano::state_block_builder builder; - auto send = builder - .account (nano::dev::genesis_key.pub) - .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis_key.pub) - .balance (nano::dev::constants.genesis_amount - 100) - .link (nano::public_key ()) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); - auto send_copy = builder.make_block ().from (*send).build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); - node1.confirmation_height_processor.add (send); - ASSERT_TIMELY (5s, node1.ledger.block_confirmed (node1.store.tx_begin_read (), send->hash ())); - ASSERT_EQ (nano::process_result::progress, node2.process (*send_copy).code); + ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); ASSERT_TIMELY (5s, !node2.active.empty ()); + // Save election to check request count afterwards - auto election2 = node2.active.election (send->qualified_root ()); - ASSERT_NE (nullptr, election2); + std::shared_ptr election2; + ASSERT_TIMELY (5s, election2 = node2.active.election (send->qualified_root ())); + ASSERT_TIMELY (5s, nano::test::confirmed (node2, { send })); ASSERT_TIMELY_EQ (5s, node2.ledger.cache.cemented_count, 2); ASSERT_TIMELY (5s, node2.active.empty ()); ASSERT_GT (election2->confirmation_request_count, 0u); From 9b6165519d7dd8b029debec20f0d6418170e83a2 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 25 Jan 2024 19:43:30 +0700 Subject: [PATCH 032/190] Simplify system::get_available_port() (#4388) The function get_available_port is too confusing. To simplify it, I am refactoring one test job it has into a separate test function. The test function speculatively chooses a free tcp binding port, for one unit test case, to check that the node can be configured with a manual port. --- nano/core_test/network.cpp | 3 +- nano/test_common/network.cpp | 25 ++++++++++++++++ nano/test_common/network.hpp | 4 +++ nano/test_common/system.cpp | 57 +++++++++--------------------------- nano/test_common/system.hpp | 7 ++++- 5 files changed, 51 insertions(+), 45 deletions(-) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 971263373c..2929ea9199 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -57,7 +57,8 @@ TEST (network, tcp_connection) TEST (network, construction_with_specified_port) { nano::test::system system{}; - auto const port = system.get_available_port (/* do not allow 0 port */ false); + auto const port = nano::test::speculatively_choose_a_free_tcp_bind_port (); + ASSERT_NE (port, 0); auto const node = system.add_node (nano::node_config{ port }); EXPECT_EQ (port, node->network.port); EXPECT_EQ (port, node->network.endpoint ().port ()); diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp index 1d584ac185..80ec2065c0 100644 --- a/nano/test_common/network.cpp +++ b/nano/test_common/network.cpp @@ -31,3 +31,28 @@ std::shared_ptr nano::test::add_outer_node (nano::test::system & sys system_a.nodes.push_back (outer_node); return outer_node; } + +// Note: this is not guaranteed to work, it is speculative +uint16_t nano::test::speculatively_choose_a_free_tcp_bind_port () +{ + /* + * This works because the kernel doesn't seem to reuse port numbers until it absolutely has to. + * Subsequent binds to port 0 will allocate a different port number. + */ + boost::asio::io_context io_ctx; + boost::asio::ip::tcp::acceptor acceptor{ io_ctx }; + boost::asio::ip::tcp::tcp::endpoint endpoint{ boost::asio::ip::tcp::v4 (), 0 }; + acceptor.open (endpoint.protocol ()); + + boost::asio::socket_base::reuse_address option{ true }; + acceptor.set_option (option); // set SO_REUSEADDR option + + acceptor.bind (endpoint); + + auto actual_endpoint = acceptor.local_endpoint (); + auto port = actual_endpoint.port (); + + acceptor.close (); + + return port; +} \ No newline at end of file diff --git a/nano/test_common/network.hpp b/nano/test_common/network.hpp index ddfb3619cd..c8835139fe 100644 --- a/nano/test_common/network.hpp +++ b/nano/test_common/network.hpp @@ -18,7 +18,11 @@ namespace test class system; /** Waits until a TCP connection is established and returns the TCP channel on success*/ std::shared_ptr establish_tcp (nano::test::system &, nano::node &, nano::endpoint const &); + /** Adds a node to the system without establishing connections */ std::shared_ptr add_outer_node (nano::test::system & system, nano::node_flags = nano::node_flags ()); + + /** speculatively (it is not guaranteed that the port will remain free) find a free tcp binding port and return it */ + uint16_t speculatively_choose_a_free_tcp_bind_port (); } } diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index eff5f455b5..aad89870d2 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -566,56 +566,27 @@ nano::node_config nano::test::system::default_config () return config; } -uint16_t nano::test::system::get_available_port (bool can_be_zero) +uint16_t nano::test::system::get_available_port () { auto base_port_str = std::getenv ("NANO_TEST_BASE_PORT"); - if (base_port_str) - { - // Maximum possible sockets which may feasibly be used in 1 test - constexpr auto max = 200; - static uint16_t current = 0; - // Read the TEST_BASE_PORT environment and override the default base port if it exists - uint16_t base_port = boost::lexical_cast (base_port_str); - - uint16_t const available_port = base_port + current; - ++current; - // Reset port number once we have reached the maximum - if (current == max) - { - current = 0; - } + if (!base_port_str) + return 0; // let the O/S decide - return available_port; - } - else - { - if (!can_be_zero) - { - /* - * This works because the kernel doesn't seem to reuse port numbers until it absolutely has to. - * Subsequent binds to port 0 will allocate a different port number. - */ - boost::asio::ip::tcp::acceptor acceptor{ io_ctx }; - boost::asio::ip::tcp::tcp::endpoint endpoint{ boost::asio::ip::tcp::v4 (), 0 }; - acceptor.open (endpoint.protocol ()); + // Maximum possible sockets which may feasibly be used in 1 test + constexpr auto max = 200; + static uint16_t current = 0; - boost::asio::socket_base::reuse_address option{ true }; - acceptor.set_option (option); // set SO_REUSEADDR option + // Read the TEST_BASE_PORT environment and override the default base port if it exists + uint16_t base_port = boost::lexical_cast (base_port_str); - acceptor.bind (endpoint); + uint16_t const available_port = base_port + current; + ++current; - auto actual_endpoint = acceptor.local_endpoint (); - auto port = actual_endpoint.port (); + // Reset port number once we have reached the maximum + if (current >= max) + current = 0; - acceptor.close (); - - return port; - } - else - { - return 0; - } - } + return available_port; } // Makes sure everything is cleaned up diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index 8e0cf19bc3..f8fed91a1e 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -61,7 +61,12 @@ namespace test * Returns default config for node running in test environment */ nano::node_config default_config (); - uint16_t get_available_port (bool can_be_zero = true); + + /* + * Returns port 0 by default, to let the O/S choose a port number. + * If NANO_TEST_BASE_PORT is set then it allocates numbers by itself from that range. + */ + uint16_t get_available_port (); public: boost::asio::io_context io_ctx; From aeddeb5934f7a2baaaafd6068aa138f965be3b4b Mon Sep 17 00:00:00 2001 From: clemahieu Date: Fri, 26 Jan 2024 00:19:38 +0000 Subject: [PATCH 033/190] Remove cleanup functions related to unchecked blocks. (#4384) These functions are no longer relevant since the blocks are now stored in memory and are bounded. --- nano/core_test/node.cpp | 39 --------------- nano/node/bootstrap/bootstrap_legacy.cpp | 4 -- nano/node/cli.cpp | 2 - nano/node/node.cpp | 64 ------------------------ nano/node/node.hpp | 2 - nano/node/nodeconfig.hpp | 2 - 6 files changed, 113 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index a0d9e63d2f..4ef62f346f 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3252,45 +3252,6 @@ TEST (node, peer_cache_restart) } } -TEST (node, unchecked_cleanup) -{ - nano::test::system system{}; - nano::node_flags node_flags{}; - node_flags.disable_unchecked_cleanup = true; - nano::keypair key{}; - auto & node = *system.add_node (node_flags); - auto open = nano::state_block_builder () - .account (key.pub) - .previous (0) - .representative (key.pub) - .balance (1) - .link (key.pub) - .sign (key.prv, key.pub) - .work (*system.work.generate (key.pub)) - .build_shared (); - std::vector bytes; - { - nano::vectorstream stream (bytes); - open->serialize (stream); - } - // Add to the blocks filter - // Should be cleared after unchecked cleanup - ASSERT_FALSE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); - node.process_active (open); - // Waits for the open block to get saved in the database - ASSERT_TIMELY_EQ (15s, 1, node.unchecked.count ()); - node.config.unchecked_cutoff_time = std::chrono::seconds (2); - ASSERT_EQ (1, node.unchecked.count ()); - std::this_thread::sleep_for (std::chrono::seconds (1)); - node.unchecked_cleanup (); - ASSERT_TRUE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); - ASSERT_EQ (1, node.unchecked.count ()); - std::this_thread::sleep_for (std::chrono::seconds (2)); - node.unchecked_cleanup (); - ASSERT_FALSE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); - ASSERT_EQ (0, node.unchecked.count ()); -} - /** This checks that a node can be opened (without being blocked) when a write lock is held elsewhere */ TEST (node, dont_write_lock_node) { diff --git a/nano/node/bootstrap/bootstrap_legacy.cpp b/nano/node/bootstrap/bootstrap_legacy.cpp index 25605c91b5..446d094646 100644 --- a/nano/node/bootstrap/bootstrap_legacy.cpp +++ b/nano/node/bootstrap/bootstrap_legacy.cpp @@ -244,10 +244,6 @@ void nano::bootstrap_attempt_legacy::run () { request_push (lock); } - if (!stopped) - { - node->unchecked_cleanup (); - } } lock.unlock (); stop (); diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index ce9369fc14..bc829fcbb5 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -131,8 +131,6 @@ std::error_code nano::update_flags (nano::node_flags & flags_a, boost::program_o flags_a.disable_bootstrap_listener = (vm.count ("disable_bootstrap_listener") > 0); } flags_a.disable_providing_telemetry_metrics = (vm.count ("disable_providing_telemetry_metrics") > 0); - flags_a.disable_unchecked_cleanup = (vm.count ("disable_unchecked_cleanup") > 0); - flags_a.disable_unchecked_drop = (vm.count ("disable_unchecked_drop") > 0); flags_a.disable_block_processor_unchecked_deletion = (vm.count ("disable_block_processor_unchecked_deletion") > 0); flags_a.enable_pruning = (vm.count ("enable_pruning") > 0); flags_a.allow_bootstrap_peers_duplicates = (vm.count ("allow_bootstrap_peers_duplicates") > 0); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 52ab7f1afd..399fe821b9 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -433,13 +433,6 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons logger.info (nano::log::type::node, "************************************ ================= ************************************"); } - - // Drop unchecked blocks if initial bootstrap is completed - if (!flags.disable_unchecked_drop && !use_bootstrap_weight && !flags.read_only) - { - logger.info (nano::log::type::node, "Dropping unchecked blocks..."); - unchecked.clear (); - } } ledger.pruning = flags.enable_pruning || store.pruned.count (store.tx_begin_read ()) > 0; @@ -610,13 +603,6 @@ void nano::node::start () { ongoing_bootstrap (); } - if (!flags.disable_unchecked_cleanup) - { - auto this_l (shared ()); - workers.push_task ([this_l] () { - this_l->ongoing_unchecked_cleanup (); - }); - } if (flags.enable_pruning) { auto this_l (shared ()); @@ -947,56 +933,6 @@ void nano::node::bootstrap_wallet () } } -void nano::node::unchecked_cleanup () -{ - std::vector digests; - std::deque cleaning_list; - auto const attempt (bootstrap_initiator.current_attempt ()); - const bool long_attempt (attempt != nullptr && std::chrono::duration_cast (std::chrono::steady_clock::now () - attempt->attempt_start).count () > config.unchecked_cutoff_time.count ()); - // Collect old unchecked keys - if (ledger.cache.block_count >= ledger.bootstrap_weight_max_blocks && !long_attempt) - { - auto const now (nano::seconds_since_epoch ()); - auto const transaction (store.tx_begin_read ()); - // Max 1M records to clean, max 2 minutes reading to prevent slow i/o systems issues - unchecked.for_each ( - [this, &digests, &cleaning_list, &now] (nano::unchecked_key const & key, nano::unchecked_info const & info) { - if ((now - info.modified ()) > static_cast (config.unchecked_cutoff_time.count ())) - { - digests.push_back (network.publish_filter.hash (info.block)); - cleaning_list.push_back (key); - } }, [iterations = 0, count = 1024 * 1024] () mutable { return iterations++ < count; }); - } - if (!cleaning_list.empty ()) - { - logger.info (nano::log::type::node, "Deleting {} old unchecked blocks", cleaning_list.size ()); - } - // Delete old unchecked keys in batches - while (!cleaning_list.empty ()) - { - std::size_t deleted_count (0); - while (deleted_count++ < 2 * 1024 && !cleaning_list.empty ()) - { - auto key (cleaning_list.front ()); - cleaning_list.pop_front (); - if (unchecked.exists (key)) - { - unchecked.del (key); - } - } - } - // Delete from the duplicate filter - network.publish_filter.clear (digests); -} - -void nano::node::ongoing_unchecked_cleanup () -{ - unchecked_cleanup (); - workers.add_timed_task (std::chrono::steady_clock::now () + network_params.node.unchecked_cleaning_interval, [this_l = shared ()] () { - this_l->ongoing_unchecked_cleanup (); - }); -} - bool nano::node::collect_ledger_pruning_targets (std::deque & pruning_targets_a, nano::account & last_account_a, uint64_t const batch_read_size_a, uint64_t const max_depth_a, uint64_t const cutoff_time_a) { uint64_t read_operations (0); diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 65d85830f0..dcdffdcf8d 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -101,11 +101,9 @@ class node final : public std::enable_shared_from_this void ongoing_rep_calculation (); void ongoing_bootstrap (); void ongoing_peer_store (); - void ongoing_unchecked_cleanup (); void backup_wallet (); void search_receivable_all (); void bootstrap_wallet (); - void unchecked_cleanup (); bool collect_ledger_pruning_targets (std::deque &, nano::account &, uint64_t const, uint64_t const, uint64_t const); void ledger_pruning (uint64_t const, bool); void ongoing_ledger_pruning (); diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index c4f8a9693b..d1a42fa370 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -152,8 +152,6 @@ class node_flags final bool disable_rep_crawler{ false }; bool disable_request_loop{ false }; // For testing only bool disable_tcp_realtime{ false }; - bool disable_unchecked_cleanup{ false }; - bool disable_unchecked_drop{ true }; bool disable_providing_telemetry_metrics{ false }; bool disable_ongoing_telemetry_requests{ false }; bool disable_block_processor_unchecked_deletion{ false }; From 28960e219fe9986b941f7edb4ce823211d60ec89 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 26 Jan 2024 10:52:49 +0700 Subject: [PATCH 034/190] Remove rule from code inspector script that enforces nano locks (#4395) --- ci/impl/code-inspector.sh | 6 ------ 1 file changed, 6 deletions(-) diff --git a/ci/impl/code-inspector.sh b/ci/impl/code-inspector.sh index d0f18faed1..0e71cf17f6 100644 --- a/ci/impl/code-inspector.sh +++ b/ci/impl/code-inspector.sh @@ -16,12 +16,6 @@ code_inspect() return 1 fi - # prevent unsolicited use of std::lock_guard, std::unique_lock, std::condition_variable & std::mutex 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\|std::mutex" $SOURCE_ROOT_PATH/nano) ]]; then - echo "Using std::unique_lock, std::lock_guard, std::condition_variable or std::mutex is not permitted (except in nano/lib/locks.hpp and non-nano dependent libraries). Use the nano::* versions instead" >&2 - return 1 - fi - if [[ $(grep -rlP "^\s*assert \(" $SOURCE_ROOT_PATH/nano) ]]; then echo "Using assert is not permitted. Use debug_assert instead." >&2 return 1 From 67841b6a797b564a8eb36688bb220b9bfeadb596 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 26 Jan 2024 11:09:25 +0700 Subject: [PATCH 035/190] Fix for NANO_TIMED_LOCKS (#4396) An include file (stacktrace.hpp) was missing --- nano/lib/locks.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/nano/lib/locks.cpp b/nano/lib/locks.cpp index 56a018b13d..3217e5e5c8 100644 --- a/nano/lib/locks.cpp +++ b/nano/lib/locks.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include From efe41eea131234bf3c035c65b9d3114614b383c3 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 26 Jan 2024 17:54:02 +0700 Subject: [PATCH 036/190] Fix bootstrap unit tests (#4383) * Introduce nano::test::system::make_disconnected_node() It makes it easy to craete a disconnected node and it also makes the intention clear, that the node is meant to be special and disconnected * Fix bootstrap_processor.process_none * Introduce nano::test::account_info and nano::test::account_height * Improve bootstrap_processor.process_one * Fix bootstrap_processor.process_two * Improve test bootstrap_processor.process_state * Improve bootstrap_processor.process_new * Improve bootstrap_processor.pull_diamond * Improve bootstrap_processor.DISABLED_pull_requeue_network_error * Improve bootstrap_processor.DISABLED_push_diamond * Improve bootstrap_processor.DISABLED_push_diamond_pruning * Improve bootstrap_processor.push_one * Fix bootstrap_processor.lazy_hash * Fix and improve bootstrap_processor.lazy_hash_bootstrap_id * Fix and improve bootstrap_processor.lazy_hash_pruning * Fix and improve bootstrap_processor.lazy_max_pull_count * Improve bootstrap_processor.lazy_unclear_state_link_not_existing * Improve bootstrap_processor.lazy_cancel * Fix bootstrap_processor.wallet_lazy_frontier * Improve bootstrap_processor.wallet_lazy_frontier * Fix bootstrap_processor.wallet_lazy_pending * Fix and improve bootstrap_processor.multiple_attempts * Improve bulk.genesis * Fix and improve bulk.offline_send * Fix bootstrap_processor.lazy_destinations * Fix bootstrap_processor.lazy_unclear_state_link_not_existing * Improve and re-enable bootstrap_processor.lazy_unclear_state_link * Fix bootstrap_processor.lazy_pruning_missing_block * Introduce function nano::test::print_all_blocks() * Fix, improve and re-enable bulk.genesis_pruning * Fix, improve and re-enable bootstrap_processor.lazy_unclear_state_link * Fix, improve and re-enable bootstrap_processor.push_diamond * Fix, improve and re-enable bootstrap_processor.push_diamond_pruning * Disable ascending and ongoing bootstrap in tests that test lazy bootstrap * Reinstate resetting of node_config.peering_port when config is reused This is needed for NANO_TEST_BASE_PORT to work. * Fix race condition in bulk.genesis_pruning * Fix a race condition in bootstrap_processor.process_new --- nano/core_test/bootstrap.cpp | 497 +++++++++++++++++++--------------- nano/test_common/system.cpp | 13 + nano/test_common/system.hpp | 5 + nano/test_common/testutil.cpp | 44 ++- nano/test_common/testutil.hpp | 15 +- 5 files changed, 360 insertions(+), 214 deletions(-) diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index ba55acd741..e73721eacf 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -280,17 +280,19 @@ TEST (bulk_pull, count_limit) ASSERT_EQ (nullptr, block); } -TEST (bootstrap_processor, DISABLED_process_none) +TEST (bootstrap_processor, process_none) { nano::test::system system (1); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node1->init_error ()); - auto done (false); + auto node0 = system.nodes[0]; + auto node1 = system.make_disconnected_node (); + + bool done = false; + node0->observers.socket_accepted.add ([&] (nano::transport::socket & socket) { + done = true; + }); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint (), false); - while (!done) - { - system.io_ctx.run_one (); - } + ASSERT_TIMELY (5s, done); node1->stop (); } @@ -307,15 +309,13 @@ TEST (bootstrap_processor, process_one) system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 100)); ASSERT_NE (nullptr, send); + ASSERT_TIMELY (5s, node0->latest (nano::dev::genesis_key.pub) != nano::dev::genesis->hash ()); - node_config.peering_port = system.get_available_port (); node_flags.disable_rep_crawler = true; - auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), node_config, system.work, node_flags)); - nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub)); - nano::block_hash hash2 (node1->latest (nano::dev::genesis_key.pub)); - ASSERT_NE (hash1, hash2); + node_config.peering_port = system.get_available_port (); + auto node1 = system.make_disconnected_node (node_config, node_flags); + ASSERT_NE (node0->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); ASSERT_TIMELY_EQ (10s, node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); node1->stop (); } @@ -329,20 +329,15 @@ TEST (bootstrap_processor, process_two) node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); - nano::block_hash hash2 (node0->latest (nano::dev::genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); - nano::block_hash hash3 (node0->latest (nano::dev::genesis_key.pub)); - ASSERT_NE (hash1, hash2); - ASSERT_NE (hash1, hash3); - ASSERT_NE (hash2, hash3); - - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node1->init_error ()); - node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); - ASSERT_TIMELY_EQ (10s, node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); + ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); + ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); + ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); + + // create a node manually to avoid making automatic network connections + auto node1 = system.make_disconnected_node (); + ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); // nodes should be out of sync here + node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); // bootstrap triggered + ASSERT_TIMELY_EQ (5s, node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); // nodes should sync up node1->stop (); } @@ -382,14 +377,13 @@ TEST (bootstrap_processor, process_state) node0->work_generate_blocking (*block2); ASSERT_EQ (nano::process_result::progress, node0->process (*block1).code); ASSERT_EQ (nano::process_result::progress, node0->process (*block2).code); + ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); - config.peering_port = system.get_available_port (); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); + auto node1 = system.make_disconnected_node (std::nullopt, node_flags); ASSERT_EQ (node0->latest (nano::dev::genesis_key.pub), block2->hash ()); ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), block2->hash ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); - ASSERT_TIMELY_EQ (10s, node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, node1->latest (nano::dev::genesis_key.pub), block2->hash ()); node1->stop (); } @@ -400,26 +394,35 @@ TEST (bootstrap_processor, process_new) config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; - auto node1 (system.add_node (config, node_flags)); + nano::keypair key2; + + auto node1 = system.add_node (config, node_flags); config.peering_port = system.get_available_port (); - auto node2 (system.add_node (config, node_flags)); + auto node2 = system.add_node (config, node_flags); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); + + // send amount raw from genesis to key2, the wallet will autoreceive + auto amount = node1->config.receive_minimum.number (); + auto send = system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, amount); ASSERT_NE (nullptr, send); - ASSERT_TIMELY (10s, !node1->balance (key2.pub).is_zero ()); - auto receive (node2->block (node2->latest (key2.pub))); - ASSERT_NE (nullptr, receive); - nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub)); - nano::uint128_t balance2 (node1->balance (key2.pub)); - ASSERT_TIMELY (10s, node1->block_confirmed (send->hash ()) && node1->block_confirmed (receive->hash ()) && node1->active.empty () && node2->active.empty ()); // All blocks should be propagated & confirmed - - auto node3 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node3->init_error ()); + ASSERT_TIMELY (5s, !node1->balance (key2.pub).is_zero ()); + + // wait for the receive block on node2 + std::shared_ptr receive; + ASSERT_TIMELY (5s, receive = node2->block (node2->latest (key2.pub))); + + // All blocks should be propagated & confirmed + ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { send, receive })); + ASSERT_TIMELY (5s, nano::test::confirmed (*node2, { send, receive })); + ASSERT_TIMELY (5s, node1->active.empty ()); + ASSERT_TIMELY (5s, node2->active.empty ()); + + // create a node manually to avoid making automatic network connections + auto node3 = system.make_disconnected_node (); node3->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node3->balance (key2.pub), balance2); - ASSERT_EQ (balance1, node3->balance (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, node3->balance (key2.pub), amount); node3->stop (); } @@ -468,11 +471,10 @@ TEST (bootstrap_processor, pull_diamond) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code); - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node1->init_error ()); + + auto node1 = system.make_disconnected_node (); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node1->balance (nano::dev::genesis_key.pub), 100); - ASSERT_EQ (100, node1->balance (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, node1->balance (nano::dev::genesis_key.pub), 100); node1->stop (); } @@ -518,32 +520,30 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error) ASSERT_EQ (0, node1->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); // Requeue is not increasing failed attempts } -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3558 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3559 -// CI run in which it failed: https://github.com/nanocurrency/nano-node/runs/4280675502?check_suite_focus=true#step:6:398 -TEST (bootstrap_processor, DISABLED_push_diamond) +TEST (bootstrap_processor, push_diamond) { nano::test::system system; - nano::node_config config = system.default_config (); - config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - auto node0 (system.add_node (config)); nano::keypair key; - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node1->init_error ()); + + auto node1 = system.make_disconnected_node (); auto wallet1 (node1->wallets.create (100)); wallet1->insert_adhoc (nano::dev::genesis_key.prv); wallet1->insert_adhoc (key.prv); + nano::block_builder builder; + + // send all balance from genesis to key auto send1 = builder .send () - .previous (node0->latest (nano::dev::genesis_key.pub)) + .previous (nano::dev::genesis->hash ()) .destination (key.pub) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + + // open key account receiving all balance of genesis auto open = builder .open () .source (send1->hash ()) @@ -553,6 +553,8 @@ TEST (bootstrap_processor, DISABLED_push_diamond) .work (*system.work.generate (key.pub)) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + + // send from key to genesis 100 raw auto send2 = builder .send () .previous (open->hash ()) @@ -562,6 +564,8 @@ TEST (bootstrap_processor, DISABLED_push_diamond) .work (*system.work.generate (open->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + + // receive the 100 raw on genesis auto receive = builder .receive () .previous (send1->hash ()) @@ -570,40 +574,49 @@ TEST (bootstrap_processor, DISABLED_push_diamond) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); - node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node0->balance (nano::dev::genesis_key.pub), 100); - ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub)); + + nano::node_config config = system.default_config (); + config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + nano::node_flags flags; + flags.disable_ongoing_bootstrap = true; + flags.disable_ascending_bootstrap = true; + auto node2 = system.add_node (config, flags); + node1->bootstrap_initiator.bootstrap (node2->network.endpoint (), false); + ASSERT_TIMELY_EQ (5s, node2->balance (nano::dev::genesis_key.pub), 100); node1->stop (); } -// Check that an outgoing bootstrap request can push blocks -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3517 -TEST (bootstrap_processor, DISABLED_push_diamond_pruning) +TEST (bootstrap_processor, push_diamond_pruning) { nano::test::system system; nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - auto node0 (system.add_node (config)); + nano::node_flags node_flags0; + node_flags0.disable_ascending_bootstrap = true; + node_flags0.disable_ongoing_bootstrap = true; + auto node0 (system.add_node (config, node_flags0)); nano::keypair key; - config.peering_port = system.get_available_port (); + config.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.enable_pruning = true; - auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); - ASSERT_FALSE (node1->init_error ()); - auto latest (node0->latest (nano::dev::genesis_key.pub)); + config.peering_port = system.get_available_port (); + auto node1 = system.make_disconnected_node (config, node_flags); + nano::block_builder builder; + + // send all balance from genesis to key auto send1 = builder .send () - .previous (latest) + .previous (nano::dev::genesis->hash ()) .destination (key.pub) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (latest)) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + + // receive all balance on key auto open = builder .open () .source (send1->hash ()) @@ -613,10 +626,15 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning) .work (*system.work.generate (key.pub)) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + // 1st bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node0->balance (key.pub), nano::dev::constants.genesis_amount); + ASSERT_TIMELY_EQ (5s, node0->balance (key.pub), nano::dev::constants.genesis_amount); + ASSERT_TIMELY_EQ (5s, node1->balance (key.pub), nano::dev::constants.genesis_amount); + // Process more blocks & prune old + + // send 100 raw from key to genesis auto send2 = builder .send () .previous (open->hash ()) @@ -626,6 +644,8 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning) .work (*system.work.generate (open->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + + // receive the 100 raw from key on genesis auto receive = builder .receive () .previous (send1->hash ()) @@ -634,11 +654,12 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + { auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 2)); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, open->hash (), 1)); - ASSERT_TRUE (node1->store.block.exists (transaction, latest)); + ASSERT_TRUE (node1->store.block.exists (transaction, nano::dev::genesis->hash ())); ASSERT_FALSE (node1->store.block.exists (transaction, send1->hash ())); ASSERT_TRUE (node1->store.pruned.exists (transaction, send1->hash ())); ASSERT_FALSE (node1->store.block.exists (transaction, open->hash ())); @@ -648,10 +669,11 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning) ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (5, node1->ledger.cache.block_count); } + // 2nd bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node0->balance (nano::dev::genesis_key.pub), 100); - ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, node0->balance (nano::dev::genesis_key.pub), 100); + ASSERT_TIMELY_EQ (5s, node1->balance (nano::dev::genesis_key.pub), 100); node1->stop (); } @@ -662,16 +684,19 @@ TEST (bootstrap_processor, push_one) config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node0 (system.add_node (config)); nano::keypair key1; - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - auto wallet (node1->wallets.create (nano::random_wallet_id ())); + auto node1 = system.make_disconnected_node (); + auto wallet = node1->wallets.create (nano::random_wallet_id ()); ASSERT_NE (nullptr, wallet); wallet->insert_adhoc (nano::dev::genesis_key.prv); - nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub)); - auto send (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); + + // send 100 raw from genesis to key1 + nano::uint128_t genesis_balance = node1->balance (nano::dev::genesis_key.pub); + auto send = wallet->send_action (nano::dev::genesis_key.pub, key1.pub, 100); ASSERT_NE (nullptr, send); - ASSERT_NE (balance1, node1->balance (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, genesis_balance - 100, node1->balance (nano::dev::genesis_key.pub)); + node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) != balance1); + ASSERT_TIMELY_EQ (5s, node0->balance (nano::dev::genesis_key.pub), genesis_balance - 100); node1->stop (); } @@ -734,9 +759,10 @@ TEST (bootstrap_processor, lazy_hash) node0->block_processor.add (receive1); node0->block_processor.add (send2); node0->block_processor.add (receive2); - node0->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*node0, { send1, receive1, send2, receive2 })); + // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); + auto node1 = system.make_disconnected_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true); { @@ -808,9 +834,10 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) node0->block_processor.add (receive1); node0->block_processor.add (send2); node0->block_processor.add (receive2); - node0->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*node0, { send1, receive1, send2, receive2 })); + // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); + auto node1 = system.make_disconnected_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true, "123456"); { @@ -832,13 +859,11 @@ TEST (bootstrap_processor, lazy_hash_pruning) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.enable_pruning = true; - auto node0 (system.add_node (config, node_flags)); - nano::keypair key1; - nano::keypair key2; - // Generating test chain + auto node0 = system.add_node (config, node_flags); nano::state_block_builder builder; + // send Gxrb_ratio raw from genesis to genesis auto send1 = builder .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -848,6 +873,8 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); + + // receive send1 auto receive1 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -858,6 +885,9 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (send1->hash ())) .build_shared (); + + // change rep of genesis account to be key1 + nano::keypair key1; auto change1 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -868,6 +898,9 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (receive1->hash ())) .build_shared (); + + // change rep of genesis account to be rep2 + nano::keypair key2; auto change2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -878,6 +911,8 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change1->hash ())) .build_shared (); + + // send Gxrb_ratio from genesis to key1 and genesis rep back to genesis account auto send2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -888,6 +923,8 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change2->hash ())) .build_shared (); + + // receive send2 and rep of key1 to be itself auto receive2 = builder .make_block () .account (key1.pub) @@ -898,6 +935,8 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) .build_shared (); + + // send Gxrb_ratio raw, all available balance, from key1 to key2 auto send3 = builder .make_block () .account (key1.pub) @@ -908,6 +947,8 @@ TEST (bootstrap_processor, lazy_hash_pruning) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive2->hash ())) .build_shared (); + + // receive send3 on key2, set rep of key2 to be itself auto receive3 = builder .make_block () .account (key2.pub) @@ -919,39 +960,42 @@ TEST (bootstrap_processor, lazy_hash_pruning) .work (*node0->work_generate_blocking (key2.pub)) .build_shared (); - // Processing test chain - node0->block_processor.add (send1); - node0->block_processor.add (receive1); - node0->block_processor.add (change1); - node0->block_processor.add (change2); - node0->block_processor.add (send2); - node0->block_processor.add (receive2); - node0->block_processor.add (send3); - node0->block_processor.add (receive3); - ASSERT_TIMELY_EQ (5s, 9, node0->ledger.cache.block_count); - // Processing chain to prune for node1 + std::vector> blocks = { send1, receive1, change1, change2, send2, receive2, send3, receive3 }; + ASSERT_TRUE (nano::test::process (*node0, blocks)); + ASSERT_TRUE (nano::test::start_elections (system, *node0, blocks, true)); + ASSERT_TIMELY (5s, nano::test::confirmed (*node0, blocks)); + config.peering_port = system.get_available_port (); - auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); - node1->start (); + auto node1 = system.make_disconnected_node (config, node_flags); + + // Processing chain to prune for node1 node1->process_active (send1); node1->process_active (receive1); node1->process_active (change1); node1->process_active (change2); - ASSERT_TIMELY (5s, node1->block (change2->hash ()) != nullptr); + ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, receive1, change1, change2 })); + // Confirm last block to prune previous ASSERT_TRUE (nano::test::start_elections (system, *node1, { send1, receive1, change1, change2 }, true)); - ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ()) && node1->block_confirmed (change1->hash ()) && node1->block_confirmed (change2->hash ()) && node1->active.empty ()); + ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ())); + ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ())); + ASSERT_TIMELY (5s, node1->block_confirmed (change1->hash ())); + ASSERT_TIMELY (5s, node1->block_confirmed (change2->hash ())); + ASSERT_TIMELY (5s, node1->active.empty ()); ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (5, node1->ledger.cache.cemented_count); + // Pruning action node1->ledger_pruning (2, false); ASSERT_EQ (9, node0->ledger.cache.block_count); ASSERT_EQ (0, node0->ledger.cache.pruned_count); ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (3, node1->ledger.cache.pruned_count); + // Start lazy bootstrap with last block in chain known nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (receive3->hash (), true); + // Check processed blocks ASSERT_TIMELY_EQ (5s, node1->ledger.cache.block_count, 9); ASSERT_TIMELY (5s, node1->balance (key2.pub) != 0); @@ -1050,21 +1094,18 @@ TEST (bootstrap_processor, lazy_max_pull_count) node0->block_processor.add (change1); node0->block_processor.add (change2); node0->block_processor.add (change3); - node0->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*node0, { send1, receive1, send2, receive2, change1, change2, change3 })); + // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); + auto node1 = system.make_disconnected_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); // Check processed blocks ASSERT_TIMELY (10s, node1->block (change3->hash ())); - node1->stop (); } -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3629 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3640 -TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) +TEST (bootstrap_processor, lazy_unclear_state_link) { nano::test::system system; nano::node_config config = system.default_config (); @@ -1072,9 +1113,10 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; auto node1 = system.add_node (config, node_flags); nano::keypair key; - // Generating test chain nano::block_builder builder; @@ -1120,14 +1162,16 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) .work (*system.work.generate (open->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + + ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive })); + // Start lazy bootstrap with last block in chain known - auto node2 = system.add_node (system.default_config (), node_flags); + auto node2 = system.make_disconnected_node (std::nullopt, node_flags); nano::test::establish_tcp (system, *node2, node1->network.endpoint ()); node2->bootstrap_initiator.bootstrap_lazy (receive->hash ()); - // Check processed blocks - ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); - ASSERT_TIMELY (5s, nano::test::block_or_pruned_all_exists (*node2, { send1, send2, open, receive })); + ASSERT_TIMELY (5s, nano::test::exists (*node2, { send1, send2, open, receive })); ASSERT_EQ (0, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); + node2->stop (); } TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) @@ -1138,6 +1182,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; auto node1 = system.add_node (config, node_flags); nano::keypair key, key2; // Generating test chain @@ -1177,16 +1223,17 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); // Start lazy bootstrap with last block in chain known - auto node2 = system.add_node (system.default_config (), node_flags); + auto node2 = system.make_disconnected_node (std::nullopt, node_flags); nano::test::establish_tcp (system, *node2, node1->network.endpoint ()); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks ASSERT_TIMELY (15s, !node2->bootstrap_initiator.in_progress ()); ASSERT_TIMELY (15s, nano::test::block_or_pruned_all_exists (*node2, { send1, open, send2 })); ASSERT_EQ (1, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); + node2->stop (); } -TEST (bootstrap_processor, DISABLED_lazy_destinations) +TEST (bootstrap_processor, lazy_destinations) { nano::test::system system; nano::node_config config = system.default_config (); @@ -1194,12 +1241,14 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; auto node1 = system.add_node (config, node_flags); nano::keypair key1, key2; - // Generating test chain nano::block_builder builder; + // send Gxrb_ratio raw from genesis to key1 auto send1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1211,6 +1260,8 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + + // send Gxrb_ratio raw from genesis to key2 auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1222,6 +1273,8 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + + // receive send1 on key1 auto open = builder .open () .source (send1->hash ()) @@ -1231,6 +1284,8 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) .work (*system.work.generate (key1.pub)) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + + // receive send2 on key2 auto state_open = builder .state () .account (key2.pub) @@ -1244,12 +1299,17 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) ASSERT_EQ (nano::process_result::progress, node1->process (*state_open).code); // Start lazy bootstrap with last block in sender chain - auto node2 = system.add_node (system.default_config (), node_flags); + auto node2 = system.make_disconnected_node (std::nullopt, node_flags); nano::test::establish_tcp (system, *node2, node1->network.endpoint ()); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); + // Check processed blocks - ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); - ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2, open, state_open })); + ASSERT_TIMELY (5s, !node2->bootstrap_initiator.in_progress ()); + ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send1->hash ())); + ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_FALSE (node2->ledger.block_or_pruned_exists (open->hash ())); + ASSERT_FALSE (node2->ledger.block_or_pruned_exists (state_open->hash ())); + node2->stop (); } TEST (bootstrap_processor, lazy_pruning_missing_block) @@ -1261,13 +1321,15 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; node_flags.enable_pruning = true; auto node1 = system.add_node (config, node_flags); nano::keypair key1, key2; - // Generating test chain nano::block_builder builder; + // send from genesis to key1 auto send1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1279,6 +1341,8 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1->process_active (send1); + + // send from genesis to key2 auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1290,6 +1354,8 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .work (*system.work.generate (send1->hash ())) .build_shared (); node1->process_active (send2); + + // open account key1 auto open = builder .open () .source (send1->hash ()) @@ -1299,6 +1365,8 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .work (*system.work.generate (key1.pub)) .build_shared (); node1->process_active (open); + + // open account key2 auto state_open = builder .state () .account (key2.pub) @@ -1314,38 +1382,41 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) ASSERT_TIMELY (5s, node1->block (state_open->hash ()) != nullptr); // Confirm last block to prune previous ASSERT_TRUE (nano::test::start_elections (system, *node1, { send1, send2, open, state_open }, true)); - ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (open->hash ()) && node1->block_confirmed (state_open->hash ())); + ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { send2, open, state_open })); ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (5, node1->ledger.cache.cemented_count); - // Pruning action + + // Pruning action, send1 should get pruned + ASSERT_EQ (0, node1->ledger.cache.pruned_count); node1->ledger_pruning (2, false); - ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (1, node1->ledger.cache.pruned_count); - ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node1, { send1, send2, open, state_open })); + ASSERT_EQ (5, node1->ledger.cache.block_count); + ASSERT_TRUE (node1->ledger.store.pruned.exists (node1->ledger.store.tx_begin_read (), send1->hash ())); + ASSERT_TRUE (nano::test::exists (*node1, { send2, open, state_open })); + // Start lazy bootstrap with last block in sender chain config.peering_port = system.get_available_port (); - auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); + auto node2 = system.make_disconnected_node (config, node_flags); nano::test::establish_tcp (system, *node2, node1->network.endpoint ()); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); + // Check processed blocks auto lazy_attempt (node2->bootstrap_initiator.current_lazy_attempt ()); ASSERT_NE (nullptr, lazy_attempt); - ASSERT_TIMELY (5s, lazy_attempt == nullptr || lazy_attempt->stopped || lazy_attempt->requeued_pulls >= 4); + ASSERT_TIMELY (5s, lazy_attempt->stopped || lazy_attempt->requeued_pulls >= 4); + // Some blocks cannot be retrieved from pruned node - node2->block_processor.flush (); ASSERT_EQ (1, node2->ledger.cache.block_count); ASSERT_TRUE (nano::test::block_or_pruned_none_exists (*node2, { send1, send2, open, state_open })); { auto transaction (node2->store.tx_begin_read ()); ASSERT_TRUE (node2->unchecked.exists (nano::unchecked_key (send2->root ().as_block_hash (), send2->hash ()))); } + // Insert missing block node2->process_active (send1); - node2->block_processor.flush (); - ASSERT_TIMELY (5s, !node2->bootstrap_initiator.in_progress ()); - node2->block_processor.flush (); - ASSERT_EQ (3, node2->ledger.cache.block_count); - ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2 })); + ASSERT_TIMELY_EQ (5s, 3, node2->ledger.cache.block_count); + ASSERT_TIMELY (5s, nano::test::exists (*node2, { send1, send2 })); ASSERT_TRUE (nano::test::block_or_pruned_none_exists (*node2, { open, state_open })); node2->stop (); } @@ -1361,9 +1432,7 @@ TEST (bootstrap_processor, lazy_cancel) nano::keypair key1; // Generating test chain - nano::state_block_builder builder; - - auto send1 = builder + auto send1 = nano::state_block_builder () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (nano::dev::genesis_key.pub) @@ -1374,7 +1443,7 @@ TEST (bootstrap_processor, lazy_cancel) .build_shared (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); + auto node1 = system.make_disconnected_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap_lazy (send1->hash (), true); // Start "confirmed" block bootstrap { @@ -1395,6 +1464,8 @@ TEST (bootstrap_processor, wallet_lazy_frontier) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; auto node0 = system.add_node (config, node_flags); nano::keypair key1; nano::keypair key2; @@ -1447,9 +1518,10 @@ TEST (bootstrap_processor, wallet_lazy_frontier) node0->block_processor.add (receive1); node0->block_processor.add (send2); node0->block_processor.add (receive2); - node0->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*node0, { send1, receive1, send2, receive2 })); + // Start wallet lazy bootstrap - auto node1 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); + auto node1 = system.make_disconnected_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); @@ -1473,6 +1545,8 @@ TEST (bootstrap_processor, wallet_lazy_pending) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; + node_flags.disable_ongoing_bootstrap = true; auto node0 = system.add_node (config, node_flags); nano::keypair key1; nano::keypair key2; @@ -1514,7 +1588,8 @@ TEST (bootstrap_processor, wallet_lazy_pending) node0->block_processor.add (send1); node0->block_processor.add (receive1); node0->block_processor.add (send2); - node0->block_processor.flush (); + nano::test::exists (*node0, { send1, receive1, send2 }); + // Start wallet lazy bootstrap auto node1 = system.add_node (); nano::test::establish_tcp (system, *node1, node0->network.endpoint ()); @@ -1585,11 +1660,13 @@ TEST (bootstrap_processor, multiple_attempts) node1->block_processor.add (receive1); node1->block_processor.add (send2); node1->block_processor.add (receive2); - node1->block_processor.flush (); + nano::test::exists (*node1, { send1, receive1, send2, receive2 }); + // Start 2 concurrent bootstrap attempts nano::node_config node_config = system.default_config (); node_config.bootstrap_initiator_threads = 3; - auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), node_config, system.work)); + + auto node2 = system.make_disconnected_node (node_config); nano::test::establish_tcp (system, *node2, node1->network.endpoint ()); node2->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true); node2->bootstrap_initiator.bootstrap (); @@ -1895,15 +1972,15 @@ TEST (frontier_req, confirmed_frontier) TEST (bulk, genesis) { nano::test::system system; - nano::node_config config (system.get_available_port ()); + nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node2->init_error ()); + + auto node2 = system.make_disconnected_node (); nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (latest1, latest2); @@ -1922,64 +1999,60 @@ TEST (bulk, genesis) TEST (bulk, offline_send) { nano::test::system system; - nano::node_config config (system.get_available_port ()); + nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; + auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work)); - ASSERT_FALSE (node2->init_error ()); - node2->start (); - system.nodes.push_back (node2); + const auto amount = node1->config.receive_minimum.number (); + auto node2 = system.make_disconnected_node (); nano::keypair key2; auto wallet (node2->wallets.create (nano::random_wallet_id ())); wallet->insert_adhoc (key2.prv); - auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); + + // send amount from genesis to key2, it will be autoreceived + auto send1 = system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, amount); ASSERT_NE (nullptr, send1); - ASSERT_NE (std::numeric_limits::max (), node1->balance (nano::dev::genesis_key.pub)); - node1->block_processor.flush (); + // Wait to finish election background tasks - ASSERT_TIMELY (10s, node1->active.empty ()); - ASSERT_TIMELY (10s, node1->block_confirmed (send1->hash ())); + ASSERT_TIMELY (5s, node1->active.empty ()); + ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ())); + ASSERT_EQ (std::numeric_limits::max () - amount, node1->balance (nano::dev::genesis_key.pub)); + // Initiate bootstrap node2->bootstrap_initiator.bootstrap (node1->network.endpoint ()); - // Nodes should find each other - system.deadline_set (10s); - do - { - ASSERT_NO_ERROR (system.poll ()); - } while (node1->network.empty () || node2->network.empty ()); + + // Nodes should find each other after bootstrap initiation + ASSERT_TIMELY (5s, !node1->network.empty ()); + ASSERT_TIMELY (5s, !node2->network.empty ()); + // Send block arrival via bootstrap - ASSERT_TIMELY (10s, node2->balance (nano::dev::genesis_key.pub) != std::numeric_limits::max ()); + ASSERT_TIMELY_EQ (5s, node2->balance (nano::dev::genesis_key.pub), std::numeric_limits::max () - amount); // Receiving send block - ASSERT_TIMELY_EQ (20s, node2->balance (key2.pub), node1->config.receive_minimum.number ()); + ASSERT_TIMELY_EQ (5s, node2->balance (key2.pub), amount); node2->stop (); } -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3611 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3613 -TEST (bulk, DISABLED_genesis_pruning) +TEST (bulk, genesis_pruning) { nano::test::system system; - nano::node_config config (system.get_available_port ()); + nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; config.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; node_flags.disable_ongoing_bootstrap = true; + node_flags.disable_ascending_bootstrap = true; node_flags.enable_pruning = true; + auto node1 = system.add_node (config, node_flags); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - node_flags.enable_pruning = false; - auto node2 (std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work, node_flags)); - ASSERT_FALSE (node2->init_error ()); - nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); - nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); - ASSERT_EQ (latest1, latest2); + + // do 3 sends from genesis to key2 nano::keypair key2; auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send1); @@ -1987,58 +2060,58 @@ TEST (bulk, DISABLED_genesis_pruning) ASSERT_NE (nullptr, send2); auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send3); + { auto transaction (node1->wallets.tx_begin_write ()); system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub); } - nano::block_hash latest3 (node1->latest (nano::dev::genesis_key.pub)); - ASSERT_NE (latest1, latest3); - ASSERT_EQ (send3->hash (), latest3); - // Confirm last block to prune previous - { - auto election = node1->active.election (send1->qualified_root ()); - ASSERT_NE (nullptr, election); - election->force_confirm (); - } - ASSERT_TIMELY (2s, node1->block_confirmed (send1->hash ()) && node1->active.active (send2->qualified_root ())); + + ASSERT_TIMELY_EQ (5s, send3->hash (), node1->latest (nano::dev::genesis_key.pub)); + + ASSERT_TRUE (nano::test::start_elections (system, *node1, { send1 }, true)); + ASSERT_TIMELY (5s, node1->active.active (send2->qualified_root ())); ASSERT_EQ (0, node1->ledger.cache.pruned_count); - { - auto election = node1->active.election (send2->qualified_root ()); - ASSERT_NE (nullptr, election); - election->force_confirm (); - } - ASSERT_TIMELY (2s, node1->block_confirmed (send2->hash ()) && node1->active.active (send3->qualified_root ())); + + ASSERT_TRUE (nano::test::start_elections (system, *node1, { send2 }, true)); + ASSERT_TIMELY (5s, node1->active.active (send3->qualified_root ())); ASSERT_EQ (0, node1->ledger.cache.pruned_count); - { - auto election = node1->active.election (send3->qualified_root ()); - ASSERT_NE (nullptr, election); - election->force_confirm (); - } - ASSERT_TIMELY (2s, node1->active.empty () && node1->block_confirmed (send3->hash ())); + + ASSERT_TRUE (nano::test::start_elections (system, *node1, { send3 }, true)); + ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { send3 })); + node1->ledger_pruning (2, false); ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (4, node1->ledger.cache.block_count); - ASSERT_TRUE (nano::test::block_or_pruned_all_exists (*node2, { send1, send2, send3 })); + ASSERT_TRUE (node1->ledger.store.pruned.exists (node1->ledger.store.tx_begin_read (), send1->hash ())); + ASSERT_FALSE (nano::test::exists (*node1, { send1 })); + ASSERT_TRUE (node1->ledger.store.pruned.exists (node1->ledger.store.tx_begin_read (), send2->hash ())); + ASSERT_FALSE (nano::test::exists (*node1, { send2 })); + ASSERT_TRUE (nano::test::exists (*node1, { send3 })); + // Bootstrap with missing blocks for node2 + node_flags.enable_pruning = false; + auto node2 = system.make_disconnected_node (std::nullopt, node_flags); node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); node2->network.merge_peer (node1->network.endpoint ()); - ASSERT_TIMELY (25s, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate, nano::stat::dir::out) >= 1 && !node2->bootstrap_initiator.in_progress ()); + ASSERT_TIMELY (5s, node2->stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate, nano::stat::dir::out) >= 1); + ASSERT_TIMELY (5s, !node2->bootstrap_initiator.in_progress ()); + // node2 still missing blocks ASSERT_EQ (1, node2->ledger.cache.block_count); { auto transaction (node2->store.tx_begin_write ()); node2->unchecked.clear (); } + // Insert pruned blocks node2->process_active (send1); node2->process_active (send2); - node2->block_processor.flush (); - ASSERT_EQ (3, node2->ledger.cache.block_count); - // New bootstrap + ASSERT_TIMELY_EQ (5s, 3, node2->ledger.cache.block_count); + + // New bootstrap to sync up everything ASSERT_TIMELY_EQ (5s, node2->bootstrap_initiator.connections->connections_count, 0); node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); - ASSERT_TIMELY_EQ (10s, node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); - ASSERT_EQ (node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); + ASSERT_TIMELY_EQ (5s, node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); node2->stop (); } diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index aad89870d2..e8fccf2200 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -125,6 +125,19 @@ std::shared_ptr nano::test::system::add_node (nano::node_config cons return node; } +std::shared_ptr nano::test::system::make_disconnected_node (std::optional opt_node_config, nano::node_flags flags) +{ + nano::node_config node_config = opt_node_config.has_value () ? *opt_node_config : default_config (); + auto node = std::make_shared (io_ctx, nano::unique_path (), node_config, work, flags); + if (node->init_error ()) + { + std::cerr << "node init error\n"; + return nullptr; + } + node->start (); + return node; +} + nano::test::system::system () { auto scale_str = std::getenv ("DEADLINE_SCALE_FACTOR"); diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index f8fed91a1e..1f6f0fa660 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -5,6 +5,7 @@ #include #include +#include namespace nano { @@ -57,6 +58,10 @@ namespace test nano::node & node (std::size_t index) const; std::shared_ptr add_node (nano::node_flags = nano::node_flags (), nano::transport::transport_type = nano::transport::transport_type::tcp); std::shared_ptr add_node (nano::node_config const &, nano::node_flags = nano::node_flags (), nano::transport::transport_type = nano::transport::transport_type::tcp, std::optional const & rep = std::nullopt); + + // Make an independent node that uses system resources but is not part of the system node list and does not automatically connect to other nodes + std::shared_ptr make_disconnected_node (std::optional opt_node_config = std::nullopt, nano::node_flags = nano::node_flags ()); + /* * Returns default config for node running in test environment */ diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 68b6e7ee92..72cb4e212f 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -273,6 +274,28 @@ bool nano::test::start_elections (nano::test::system & system_a, nano::node & no return nano::test::start_elections (system_a, node_a, blocks_to_hashes (blocks_a), forced_a); } +nano::account_info nano::test::account_info (nano::node const & node, nano::account const & acc) +{ + auto const tx = node.ledger.store.tx_begin_read (); + auto opt = node.ledger.account_info (tx, acc); + if (opt.has_value ()) + { + return opt.value (); + } + return {}; +} + +uint64_t nano::test::account_height (nano::node const & node, nano::account const & acc) +{ + auto const tx = node.ledger.store.tx_begin_read (); + nano::confirmation_height_info height_info; + if (!node.ledger.store.confirmation_height.get (tx, acc, height_info)) + { + return 0; + } + return height_info.height; +} + void nano::test::print_all_account_info (nano::node & node) { auto const tx = node.ledger.store.tx_begin_read (); @@ -292,4 +315,23 @@ void nano::test::print_all_account_info (nano::node & node) std::cout << " Conf. Frontier: " << height_info.frontier.to_string () << std::endl; } } -} \ No newline at end of file +} + +void nano::test::print_all_blocks (nano::node & node) +{ + auto tx = node.store.tx_begin_read (); + auto i = node.store.block.begin (tx); + auto end = node.store.block.end (); + std::cout << "Listing all blocks" << std::endl; + for (; i != end; ++i) + { + nano::block_hash hash = i->first; + nano::store::block_w_sideband sideband = i->second; + std::shared_ptr b = sideband.block; + std::cout << "Hash: " << hash.to_string () << std::endl; + const auto acc = sideband.sideband.account; + std::cout << "Acc: " << acc.to_string () << "(" << acc.to_account () << ")" << std::endl; + std::cout << "Height: " << sideband.sideband.height << std::endl; + std::cout << b->to_json (); + } +} diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index 3696d8791a..286de73207 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -387,11 +387,24 @@ namespace test */ [[nodiscard]] bool start_elections (nano::test::system &, nano::node &, std::vector> const &, bool const forced_a = false); + /** + * Return account_info for account "acc", if account is not found, a default initialised object is returned + */ + nano::account_info account_info (nano::node const & node, nano::account const & acc); + + /** + * Return the account height, returns 0 on error + */ + uint64_t account_height (nano::node const & node, nano::account const & acc); + /** * \brief Debugging function to print all accounts in a ledger. Intented to be used to debug unit tests. - * \param ledger */ void print_all_account_info (nano::node & node); + /** + * \brief Debugging function to print all blocks in a node. Intented to be used to debug unit tests. + */ + void print_all_blocks (nano::node & node); } } From 7ce38c8ea4bbfd140ea98fd8dfe7486b3ce00522 Mon Sep 17 00:00:00 2001 From: gr0vity-dev <85646666+gr0vity-dev@users.noreply.github.com> Date: Fri, 26 Jan 2024 13:20:35 +0100 Subject: [PATCH 037/190] Fix failing TEST (active_transactions, fifo) (#4394) This testcase manually pushes two blocks to the election scheduler. However the backlog population sometimes also pushes the block to the election scheduler resulting in it being dropped twice. --> The solution is to disable the backlog population for this testcase --- nano/core_test/active_transactions.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 42644411e7..a5d6287e8d 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1355,6 +1355,7 @@ TEST (active_transactions, fifo) nano::node_config config = system.default_config (); config.active_elections_size = 1; + config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (config); auto latest_hash = nano::dev::genesis->hash (); From 6b6df38cd5d5b8c08a108b6ac993f742fe5d1832 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 26 Jan 2024 23:05:30 +0700 Subject: [PATCH 038/190] Avoid printing warning about cerr and colors in default cli mode (#4400) In cli mode, we default to colors plus cerr so we always get a warning about colors not showing cerr. Now it defaults to cerr and no colors and the warning does not show up. --- nano/lib/logging.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 4147ea5a3e..3630c23d02 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -282,6 +282,7 @@ nano::log_config nano::log_config::cli_default () { log_config config{}; config.default_level = nano::log::level::critical; + config.console.colors = false; // to avoid printing warning about cerr and colors config.console.to_cerr = true; // Use cerr to avoid interference with CLI output that goes to stdout config.file.enable = false; return config; From 9e2303222b916d14bc68f87e51e09980e87fc083 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 26 Jan 2024 18:35:11 +0100 Subject: [PATCH 039/190] Improve enum conversions (#4397) * Simplify enum conversions * Make stats and parse status enums compatible * Simplify conversion * Move `parse_status` and auxiliary functions to more a appropriate namespace * More simplifications * Use ADL for `to_stat_detail (...)` calls * Update magic_enum version * Customize enum ranges for reflection * Add enum safeguards and test accordingly --- CMakeLists.txt | 2 +- nano/core_test/enums.cpp | 42 +++++++++++ nano/core_test/message_deserializer.cpp | 2 +- nano/core_test/network.cpp | 8 +-- nano/lib/logging_enums.cpp | 23 ++---- nano/lib/logging_enums.hpp | 23 ++++++ nano/lib/stats_enums.cpp | 3 - nano/lib/stats_enums.hpp | 24 ++++++- nano/lib/utility.hpp | 35 +++++++++ nano/node/active_transactions.cpp | 4 +- nano/node/election.cpp | 23 ++---- nano/node/messages.cpp | 76 ++------------------ nano/node/network.cpp | 2 +- nano/node/transport/channel.cpp | 2 +- nano/node/transport/inproc.cpp | 2 +- nano/node/transport/message_deserializer.cpp | 74 ++----------------- nano/node/transport/message_deserializer.hpp | 56 +++++++-------- nano/node/transport/tcp_server.cpp | 16 ++--- nano/secure/common.cpp | 36 +--------- submodules/magic_enum | 2 +- 20 files changed, 192 insertions(+), 263 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6218ab5fdb..a4c1ba48de 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -526,7 +526,7 @@ add_subdirectory(submodules/rocksdb EXCLUDE_FROM_ALL) include_directories(submodules/cpptoml/include) # magic_enum -include_directories(submodules/magic_enum/include) +include_directories(submodules/magic_enum/include/magic_enum) add_subdirectory(crypto/ed25519-donna) diff --git a/nano/core_test/enums.cpp b/nano/core_test/enums.cpp index ae60532ed2..53b25a6d33 100644 --- a/nano/core_test/enums.cpp +++ b/nano/core_test/enums.cpp @@ -7,17 +7,59 @@ TEST (enums, stat_type) { ASSERT_FALSE (nano::to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (static_cast (0)) }); + ASSERT_FALSE (nano::to_string (nano::stat::type::_last).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (nano::stat::type::_last) }); + ASSERT_EQ (nano::to_string (nano::stat::type::_last), "_last"); } TEST (enums, stat_detail) { ASSERT_FALSE (nano::to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (static_cast (0)) }); + ASSERT_FALSE (nano::to_string (nano::stat::detail::_last).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (nano::stat::detail::_last) }); + ASSERT_EQ (nano::to_string (nano::stat::detail::_last), "_last"); } TEST (enums, stat_dir) { ASSERT_FALSE (nano::to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (static_cast (0)) }); + ASSERT_FALSE (nano::to_string (nano::stat::dir::_last).empty ()); + ASSERT_NO_THROW (std::string{ nano::to_string (nano::stat::dir::_last) }); + ASSERT_EQ (nano::to_string (nano::stat::dir::_last), "_last"); +} + +TEST (enums, log_type) +{ + ASSERT_FALSE (to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ to_string (static_cast (0)) }); + + ASSERT_FALSE (to_string (nano::log::type::_last).empty ()); + ASSERT_NO_THROW (std::string{ to_string (nano::log::type::_last) }); + ASSERT_EQ (to_string (nano::log::type::_last), "_last"); +} + +TEST (enums, log_detail) +{ + ASSERT_FALSE (to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ to_string (static_cast (0)) }); + + ASSERT_FALSE (to_string (nano::log::detail::_last).empty ()); + ASSERT_NO_THROW (std::string{ to_string (nano::log::detail::_last) }); + ASSERT_EQ (to_string (nano::log::detail::_last), "_last"); +} + +TEST (enums, log_category) +{ + ASSERT_FALSE (to_string (static_cast (0)).empty ()); + ASSERT_NO_THROW (std::string{ to_string (static_cast (0)) }); + + ASSERT_FALSE (to_string (nano::log::type::_last).empty ()); + ASSERT_NO_THROW (std::string{ to_string (nano::log::type::_last) }); + ASSERT_EQ (to_string (nano::log::type::_last), "_last"); } \ No newline at end of file diff --git a/nano/core_test/message_deserializer.cpp b/nano/core_test/message_deserializer.cpp index e78d0fed23..0954b2c0c4 100644 --- a/nano/core_test/message_deserializer.cpp +++ b/nano/core_test/message_deserializer.cpp @@ -51,7 +51,7 @@ auto message_deserializer_success_checker (message_type & message_original) -> v ASSERT_EQ (*deserialized_bytes, *original_bytes); }); // This is a sanity test, to ensure the successful deserialization case passes. - ASSERT_EQ (message_deserializer->status, nano::transport::message_deserializer::parse_status::success); + ASSERT_EQ (message_deserializer->status, nano::transport::parse_status::success); } TEST (message_deserializer, exact_confirm_ack) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 2929ea9199..fdc49ccd8d 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -796,16 +796,16 @@ TEST (network, duplicate_detection) auto & node1 = *system.add_node (node_flags); nano::publish publish{ nano::dev::network_params.network, nano::dev::genesis }; - ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish)); + ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish_message)); // Publish duplicate detection through TCP auto tcp_channel = node0.network.tcp_channels.find_node_id (node1.get_node_id ()); ASSERT_NE (nullptr, tcp_channel); - ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish)); + ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish_message)); tcp_channel->send (publish); - ASSERT_TIMELY_EQ (2s, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish), 0); + ASSERT_TIMELY_EQ (2s, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish_message), 0); tcp_channel->send (publish); - ASSERT_TIMELY_EQ (2s, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish), 1); + ASSERT_TIMELY_EQ (2s, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish_message), 1); } TEST (network, duplicate_revert_publish) diff --git a/nano/lib/logging_enums.cpp b/nano/lib/logging_enums.cpp index b1a55f4485..a7bbd1c7ba 100644 --- a/nano/lib/logging_enums.cpp +++ b/nano/lib/logging_enums.cpp @@ -1,6 +1,3 @@ -#define MAGIC_ENUM_RANGE_MIN 0 -#define MAGIC_ENUM_RANGE_MAX 256 - #include #include @@ -24,12 +21,7 @@ std::string_view nano::log::to_string (nano::log::level level) const std::vector & nano::log::all_levels () { static std::vector all = [] () { - std::vector result; - for (auto const & lvl : magic_enum::enum_values ()) - { - result.push_back (lvl); - } - return result; + return nano::util::enum_values (); }(); return all; } @@ -37,19 +29,14 @@ const std::vector & nano::log::all_levels () const std::vector & nano::log::all_types () { static std::vector all = [] () { - std::vector result; - for (auto const & lvl : magic_enum::enum_values ()) - { - result.push_back (lvl); - } - return result; + return nano::util::enum_values (); }(); return all; } nano::log::level nano::log::parse_level (std::string_view name) { - auto value = magic_enum::enum_cast (name); + auto value = nano::util::parse_enum (name); if (value.has_value ()) { return value.value (); @@ -66,7 +53,7 @@ nano::log::level nano::log::parse_level (std::string_view name) nano::log::type nano::log::parse_type (std::string_view name) { - auto value = magic_enum::enum_cast (name); + auto value = nano::util::parse_enum (name); if (value.has_value ()) { return value.value (); @@ -79,7 +66,7 @@ nano::log::type nano::log::parse_type (std::string_view name) nano::log::detail nano::log::parse_detail (std::string_view name) { - auto value = magic_enum::enum_cast (name); + auto value = nano::util::parse_enum (name); if (value.has_value ()) { return value.value (); diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index a0e5306256..af2ebfda84 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -4,6 +4,8 @@ #include #include +#include + namespace nano::log { enum class level @@ -74,6 +76,8 @@ enum class type bootstrap, bootstrap_lazy, bootstrap_legacy, + + _last // Must be the last enum }; enum class detail @@ -110,6 +114,7 @@ enum class detail requesting_account_or_head, requesting_pending, + _last // Must be the last enum }; // TODO: Additionally categorize logs by categories which can be enabled/disabled independently @@ -119,6 +124,8 @@ enum class category work_generation, // ... + + _last // Must be the last enum }; } @@ -140,3 +147,19 @@ nano::log::detail parse_detail (std::string_view); std::vector const & all_levels (); std::vector const & all_types (); } + +// Ensure that the enum_range is large enough to hold all values (including future ones) +template <> +struct magic_enum::customize::enum_range +{ + static constexpr int min = 0; + static constexpr int max = 128; +}; + +// Ensure that the enum_range is large enough to hold all values (including future ones) +template <> +struct magic_enum::customize::enum_range +{ + static constexpr int min = 0; + static constexpr int max = 512; +}; \ No newline at end of file diff --git a/nano/lib/stats_enums.cpp b/nano/lib/stats_enums.cpp index 0e77882d6d..8da30854e9 100644 --- a/nano/lib/stats_enums.cpp +++ b/nano/lib/stats_enums.cpp @@ -1,8 +1,5 @@ #include -#define MAGIC_ENUM_RANGE_MIN 0 -#define MAGIC_ENUM_RANGE_MAX 256 - #include std::string_view nano::to_string (nano::stat::type type) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index ff9ef58190..b6373996ca 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -3,6 +3,8 @@ #include #include +#include + namespace nano::stat { /** Primary statistics type */ @@ -67,6 +69,8 @@ enum class detail : uint8_t broadcast, cleanup, top, + none, + success, // processing queue queue, @@ -172,7 +176,7 @@ enum class detail : uint8_t invalid_frontier_req_message, invalid_asc_pull_req_message, invalid_asc_pull_ack_message, - message_too_big, + message_size_too_big, outdated_version, // tcp @@ -210,7 +214,7 @@ enum class detail : uint8_t requests_unknown, // duplicate - duplicate_publish, + duplicate_publish_message, // telemetry invalid_signature, @@ -317,3 +321,19 @@ std::string_view to_string (stat::type); std::string_view to_string (stat::detail); std::string_view to_string (stat::dir); } + +// Ensure that the enum_range is large enough to hold all values (including future ones) +template <> +struct magic_enum::customize::enum_range +{ + static constexpr int min = 0; + static constexpr int max = 128; +}; + +// Ensure that the enum_range is large enough to hold all values (including future ones) +template <> +struct magic_enum::customize::enum_range +{ + static constexpr int min = 0; + static constexpr int max = 512; +}; \ No newline at end of file diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 72ea310dae..61beefeeb4 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -14,6 +14,7 @@ #include #include +#include #include namespace boost @@ -262,4 +263,38 @@ std::string to_str (T const & val) { return boost::lexical_cast (val); } + +/** + * Same as `magic_enum::enum_values (...)` but ignores reserved values (starting with underscore) + */ +template +std::vector enum_values () +{ + std::vector result; + for (auto const & [val, name] : magic_enum::enum_entries ()) + { + if (!name.starts_with ('_')) + { + result.push_back (val); + } + } + return result; +} + +/** + * Same as `magic_enum::enum_cast (...)` but ignores reserved values (starting with underscore). + * Case insensitive. + */ +template +std::optional parse_enum (std::string_view name) +{ + if (name.starts_with ('_')) + { + return std::nullopt; + } + else + { + return magic_enum::enum_cast (name, magic_enum::case_insensitive); + } +} } \ No newline at end of file diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 29cdbf3c91..a66f69119d 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -324,7 +324,7 @@ void nano::active_transactions::cleanup_election (nano::unique_lock lock_a.unlock (); - node.stats.inc (completion_type (*election), nano::to_stat_detail (election->behavior ())); + node.stats.inc (completion_type (*election), to_stat_detail (election->behavior ())); vacancy_update (); @@ -461,7 +461,7 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p { cache->fill (result.election); } - node.stats.inc (nano::stat::type::active_started, nano::to_stat_detail (election_behavior_a)); + node.stats.inc (nano::stat::type::active_started, to_stat_detail (election_behavior_a)); node.observers.active_started.notify (hash); vacancy_update (); } diff --git a/nano/node/election.cpp b/nano/node/election.cpp index ab4aab345c..0ef35b349e 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -5,6 +5,8 @@ #include +#include + using namespace std::chrono; std::chrono::milliseconds nano::election::base_latency () const @@ -693,24 +695,9 @@ std::vector nano::election::votes_with_weight () co nano::stat::detail nano::to_stat_detail (nano::election_behavior behavior) { - switch (behavior) - { - case nano::election_behavior::normal: - { - return nano::stat::detail::normal; - } - case nano::election_behavior::hinted: - { - return nano::stat::detail::hinted; - } - case nano::election_behavior::optimistic: - { - return nano::stat::detail::optimistic; - } - } - - debug_assert (false, "unknown election behavior"); - return {}; + auto value = magic_enum::enum_cast (magic_enum::enum_name (behavior)); + debug_assert (value); + return value.value_or (nano::stat::detail{}); } nano::election_behavior nano::election::behavior () const diff --git a/nano/node/messages.cpp b/nano/node/messages.cpp index 0631dcddfa..b27e26c151 100644 --- a/nano/node/messages.cpp +++ b/nano/node/messages.cpp @@ -1995,80 +1995,12 @@ void nano::asc_pull_ack::frontiers_payload::deserialize (nano::stream & stream) std::string_view nano::to_string (nano::message_type type) { - switch (type) - { - case nano::message_type::invalid: - return "invalid"; - case nano::message_type::not_a_type: - return "not_a_type"; - case nano::message_type::keepalive: - return "keepalive"; - case nano::message_type::publish: - return "publish"; - case nano::message_type::confirm_req: - return "confirm_req"; - case nano::message_type::confirm_ack: - return "confirm_ack"; - case nano::message_type::bulk_pull: - return "bulk_pull"; - case nano::message_type::bulk_push: - return "bulk_push"; - case nano::message_type::frontier_req: - return "frontier_req"; - case nano::message_type::node_id_handshake: - return "node_id_handshake"; - case nano::message_type::bulk_pull_account: - return "bulk_pull_account"; - case nano::message_type::telemetry_req: - return "telemetry_req"; - case nano::message_type::telemetry_ack: - return "telemetry_ack"; - case nano::message_type::asc_pull_req: - return "asc_pull_req"; - case nano::message_type::asc_pull_ack: - return "asc_pull_ack"; - // default case intentionally omitted to cause warnings for unhandled enums - } - - return "n/a"; + return magic_enum::enum_name (type); } nano::stat::detail nano::to_stat_detail (nano::message_type type) { - switch (type) - { - case nano::message_type::invalid: - return nano::stat::detail::invalid; - case nano::message_type::not_a_type: - return nano::stat::detail::not_a_type; - case nano::message_type::keepalive: - return nano::stat::detail::keepalive; - case nano::message_type::publish: - return nano::stat::detail::publish; - case nano::message_type::confirm_req: - return nano::stat::detail::confirm_req; - case nano::message_type::confirm_ack: - return nano::stat::detail::confirm_ack; - case nano::message_type::bulk_pull: - return nano::stat::detail::bulk_pull; - case nano::message_type::bulk_push: - return nano::stat::detail::bulk_push; - case nano::message_type::frontier_req: - return nano::stat::detail::frontier_req; - case nano::message_type::node_id_handshake: - return nano::stat::detail::node_id_handshake; - case nano::message_type::bulk_pull_account: - return nano::stat::detail::bulk_pull_account; - case nano::message_type::telemetry_req: - return nano::stat::detail::telemetry_req; - case nano::message_type::telemetry_ack: - return nano::stat::detail::telemetry_ack; - case nano::message_type::asc_pull_req: - return nano::stat::detail::asc_pull_req; - case nano::message_type::asc_pull_ack: - return nano::stat::detail::asc_pull_ack; - // default case intentionally omitted to cause warnings for unhandled enums - } - debug_assert (false); - return {}; + auto value = magic_enum::enum_cast (magic_enum::enum_name (type)); + debug_assert (value); + return value.value_or (nano::stat::detail{}); } diff --git a/nano/node/network.cpp b/nano/node/network.cpp index d02026deac..9f33370cc1 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -468,7 +468,7 @@ class network_message_visitor : public nano::message_visitor void nano::network::process_message (nano::message const & message, std::shared_ptr const & channel) { - node.stats.inc (nano::stat::type::message, nano::to_stat_detail (message.header.type), nano::stat::dir::in); + node.stats.inc (nano::stat::type::message, to_stat_detail (message.header.type), nano::stat::dir::in); network_message_visitor visitor{ node, channel }; message.visit (visitor); diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 4649726786..99581f4712 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -17,7 +17,7 @@ nano::transport::channel::channel (nano::node & node_a) : void nano::transport::channel::send (nano::message & message_a, std::function const & callback_a, nano::transport::buffer_drop_policy drop_policy_a, nano::transport::traffic_type traffic_type) { auto buffer (message_a.to_shared_const_buffer ()); - auto detail = nano::to_stat_detail (message_a.header.type); + auto detail = to_stat_detail (message_a.header.type); auto is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter); auto should_pass (node.outbound_limiter.should_pass (buffer.size (), to_bandwidth_limit_type (traffic_type))); if (!is_droppable_by_limiter || should_pass) diff --git a/nano/node/transport/inproc.cpp b/nano/node/transport/inproc.cpp index a015a2fdbc..b07bd0d35f 100644 --- a/nano/node/transport/inproc.cpp +++ b/nano/node/transport/inproc.cpp @@ -78,7 +78,7 @@ void nano::transport::inproc::channel::send_buffer (nano::shared_const_buffer co // process message { - node.stats.inc (nano::stat::type::message, nano::to_stat_detail (message_a->header.type), nano::stat::dir::in); + node.stats.inc (nano::stat::type::message, to_stat_detail (message_a->header.type), nano::stat::dir::in); // create an inbound message visitor class to handle incoming messages message_visitor_inbound visitor{ destination.network.inbound, remote_channel }; diff --git a/nano/node/transport/message_deserializer.cpp b/nano/node/transport/message_deserializer.cpp index f5e2ba11c1..174a875eb7 100644 --- a/nano/node/transport/message_deserializer.cpp +++ b/nano/node/transport/message_deserializer.cpp @@ -382,78 +382,14 @@ std::unique_ptr nano::transport::message_deserializer::deser return {}; } -nano::stat::detail nano::to_stat_detail (nano::transport::message_deserializer::parse_status status) +nano::stat::detail nano::transport::to_stat_detail (nano::transport::parse_status status) { - using parse_status = nano::transport::message_deserializer::parse_status; - - // Keep additional `break` for readability - switch (status) - { - case parse_status::none: - case parse_status::success: - break; - case parse_status::insufficient_work: - return stat::detail::insufficient_work; - break; - case parse_status::invalid_header: - return stat::detail::invalid_header; - break; - case parse_status::invalid_message_type: - return stat::detail::invalid_message_type; - break; - case parse_status::invalid_keepalive_message: - return stat::detail::invalid_keepalive_message; - break; - case parse_status::invalid_publish_message: - return stat::detail::invalid_publish_message; - break; - case parse_status::invalid_confirm_req_message: - return stat::detail::invalid_confirm_req_message; - break; - case parse_status::invalid_confirm_ack_message: - return stat::detail::invalid_confirm_ack_message; - break; - case parse_status::invalid_node_id_handshake_message: - return stat::detail::invalid_node_id_handshake_message; - break; - case parse_status::invalid_telemetry_req_message: - return stat::detail::invalid_telemetry_req_message; - break; - case parse_status::invalid_telemetry_ack_message: - return stat::detail::invalid_telemetry_ack_message; - break; - case parse_status::invalid_bulk_pull_message: - return stat::detail::invalid_bulk_pull_message; - break; - case parse_status::invalid_bulk_pull_account_message: - return stat::detail::invalid_bulk_pull_account_message; - break; - case parse_status::invalid_frontier_req_message: - return stat::detail::invalid_frontier_req_message; - break; - case parse_status::invalid_asc_pull_req_message: - return stat::detail::invalid_asc_pull_req_message; - break; - case parse_status::invalid_asc_pull_ack_message: - return stat::detail::invalid_asc_pull_ack_message; - break; - case parse_status::invalid_network: - return stat::detail::invalid_network; - break; - case parse_status::outdated_version: - return stat::detail::outdated_version; - break; - case parse_status::duplicate_publish_message: - return stat::detail::duplicate_publish; - break; - case parse_status::message_size_too_big: - return stat::detail::message_too_big; - break; - } - return {}; + auto value = magic_enum::enum_cast (magic_enum::enum_name (status)); + debug_assert (value); + return value.value_or (nano::stat::detail{}); } -std::string_view nano::to_string (nano::transport::message_deserializer::parse_status status) +std::string_view nano::transport::to_string (nano::transport::parse_status status) { return magic_enum::enum_name (status); } diff --git a/nano/node/transport/message_deserializer.hpp b/nano/node/transport/message_deserializer.hpp index 9a2fbc21c6..c5ac4346b9 100644 --- a/nano/node/transport/message_deserializer.hpp +++ b/nano/node/transport/message_deserializer.hpp @@ -10,34 +10,34 @@ namespace nano { namespace transport { + enum class parse_status + { + none, + success, + insufficient_work, + invalid_header, + invalid_message_type, + invalid_keepalive_message, + invalid_publish_message, + invalid_confirm_req_message, + invalid_confirm_ack_message, + invalid_node_id_handshake_message, + invalid_telemetry_req_message, + invalid_telemetry_ack_message, + invalid_bulk_pull_message, + invalid_bulk_pull_account_message, + invalid_frontier_req_message, + invalid_asc_pull_req_message, + invalid_asc_pull_ack_message, + invalid_network, + outdated_version, + duplicate_publish_message, + message_size_too_big, + }; + class message_deserializer : public std::enable_shared_from_this { public: - enum class parse_status - { - none, - success, - insufficient_work, - invalid_header, - invalid_message_type, - invalid_keepalive_message, - invalid_publish_message, - invalid_confirm_req_message, - invalid_confirm_ack_message, - invalid_node_id_handshake_message, - invalid_telemetry_req_message, - invalid_telemetry_ack_message, - invalid_bulk_pull_message, - invalid_bulk_pull_account_message, - invalid_frontier_req_message, - invalid_asc_pull_req_message, - invalid_asc_pull_ack_message, - invalid_network, - outdated_version, - duplicate_publish_message, - message_size_too_big, - }; - using callback_type = std::function)>; parse_status status; @@ -90,8 +90,8 @@ namespace transport nano::vote_uniquer & vote_uniquer_m; read_query read_op; }; -} -nano::stat::detail to_stat_detail (nano::transport::message_deserializer::parse_status); -std::string_view to_string (nano::transport::message_deserializer::parse_status); + nano::stat::detail to_stat_detail (parse_status); + std::string_view to_string (parse_status); +} } diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 9d02482b11..af163701a5 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -372,10 +372,10 @@ void nano::transport::tcp_server::receive_message () if (ec) { // IO error or critical error when deserializing message - node->stats.inc (nano::stat::type::error, nano::to_stat_detail (this_l->message_deserializer->status)); + node->stats.inc (nano::stat::type::error, to_stat_detail (this_l->message_deserializer->status)); node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})", ec.message (), - nano::to_string (this_l->message_deserializer->status), + to_string (this_l->message_deserializer->status), nano::util::to_str (this_l->remote_endpoint)); this_l->stop (); @@ -402,18 +402,18 @@ void nano::transport::tcp_server::received_message (std::unique_ptrstatus != transport::message_deserializer::parse_status::success); + debug_assert (message_deserializer->status != transport::parse_status::success); - node->stats.inc (nano::stat::type::error, nano::to_stat_detail (message_deserializer->status)); - if (message_deserializer->status == transport::message_deserializer::parse_status::duplicate_publish_message) + node->stats.inc (nano::stat::type::error, to_stat_detail (message_deserializer->status)); + if (message_deserializer->status == transport::parse_status::duplicate_publish_message) { - node->stats.inc (nano::stat::type::filter, nano::stat::detail::duplicate_publish); + node->stats.inc (nano::stat::type::filter, nano::stat::detail::duplicate_publish_message); } else { // Avoid too much noise about `duplicate_publish_message` errors node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})", - nano::to_string (message_deserializer->status), + to_string (message_deserializer->status), nano::util::to_str (remote_endpoint)); } } @@ -431,7 +431,7 @@ bool nano::transport::tcp_server::process_message (std::unique_ptrstats.inc (nano::stat::type::tcp_server, nano::to_stat_detail (message->header.type), nano::stat::dir::in); + node->stats.inc (nano::stat::type::tcp_server, to_stat_detail (message->header.type), nano::stat::dir::in); debug_assert (is_undefined_connection () || is_realtime_connection () || is_bootstrap_connection ()); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 525083669d..2fe551a788 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -498,37 +498,7 @@ void nano::generate_cache::enable_all () nano::stat::detail nano::to_stat_detail (nano::process_result process_result) { - switch (process_result) - { - case process_result::progress: - return nano::stat::detail::progress; - case process_result::bad_signature: - return nano::stat::detail::bad_signature; - case process_result::old: - return nano::stat::detail::old; - case process_result::negative_spend: - return nano::stat::detail::negative_spend; - case process_result::fork: - return nano::stat::detail::fork; - case process_result::unreceivable: - return nano::stat::detail::unreceivable; - case process_result::gap_previous: - return nano::stat::detail::gap_previous; - case process_result::gap_source: - return nano::stat::detail::gap_source; - case process_result::gap_epoch_open_pending: - return nano::stat::detail::gap_epoch_open_pending; - case process_result::opened_burn_account: - return nano::stat::detail::opened_burn_account; - case process_result::balance_mismatch: - return nano::stat::detail::balance_mismatch; - case process_result::representative_mismatch: - return nano::stat::detail::representative_mismatch; - case process_result::block_position: - return nano::stat::detail::block_position; - case process_result::insufficient_work: - return nano::stat::detail::insufficient_work; - } - debug_assert (false && "There should be always a defined nano::stat::detail that is not _last"); - return nano::stat::detail::_last; + auto value = magic_enum::enum_cast (magic_enum::enum_name (process_result)); + debug_assert (value); + return value.value_or (nano::stat::detail{}); } diff --git a/submodules/magic_enum b/submodules/magic_enum index 533c9509ef..e55b9b54d5 160000 --- a/submodules/magic_enum +++ b/submodules/magic_enum @@ -1 +1 @@ -Subproject commit 533c9509ef77d0fedd8be47d16dc6310877e24cf +Subproject commit e55b9b54d5cf61f8e117cafb17846d7d742dd3b4 From e518551bf076529b469c97b04230d1d9ad16cf4d Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Sat, 27 Jan 2024 09:14:20 +0100 Subject: [PATCH 040/190] Use make_final_vote function (#4407) resolves #4402 --- nano/core_test/active_transactions.cpp | 16 ++++++++-------- nano/core_test/node.cpp | 6 +++--- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index a5d6287e8d..403b37ae04 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -251,7 +251,7 @@ TEST (active_transactions, inactive_votes_cache) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, send->hash ()))); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send }); node.vote_processor.vote (vote, std::make_shared (node, node)); ASSERT_TIMELY_EQ (5s, node.vote_cache.size (), 1); node.process_active (send); @@ -314,7 +314,7 @@ TEST (active_transactions, inactive_votes_cache_fork) .work (*system.work.generate (latest)) .build_shared (); - auto const vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, send1->hash ())); + auto const vote = nano::test::make_final_vote (nano::dev::genesis_key, { send1 }); node.vote_processor.vote (vote, std::make_shared (node, node)); ASSERT_TIMELY_EQ (5s, node.vote_cache.size (), 1); @@ -580,7 +580,7 @@ TEST (active_transactions, vote_replays) ASSERT_TRUE (nano::test::start_elections (system, node, { send1, open1 })); ASSERT_EQ (2, node.active.size ()); // First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed - auto vote_send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ send1->hash () })); + auto vote_send1 = nano::test::make_final_vote (nano::dev::genesis_key, { send1 }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1)); ASSERT_EQ (2, node.active.size ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); @@ -588,7 +588,7 @@ TEST (active_transactions, vote_replays) ASSERT_TIMELY_EQ (3s, node.active.size (), 1); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); // Open new account - auto vote_open1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ open1->hash () })); + auto vote_open1 = nano::test::make_final_vote (nano::dev::genesis_key, { open1 }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1)); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_TIMELY (3s, node.active.empty ()); @@ -608,7 +608,7 @@ TEST (active_transactions, vote_replays) node.process_active (send2); ASSERT_TRUE (nano::test::start_elections (system, node, { send2 })); ASSERT_EQ (1, node.active.size ()); - auto vote1_send2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ send2->hash () })); + auto vote1_send2 = nano::test::make_final_vote (nano::dev::genesis_key, { send2 }); auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, 0, std::vector{ send2->hash () })); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2)); ASSERT_EQ (1, node.active.size ()); @@ -750,7 +750,7 @@ TEST (active_transactions, republish_winner) node1.block_processor.flush (); auto election = node1.active.election (fork->qualified_root ()); ASSERT_NE (nullptr, election); - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ fork->hash () }); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); node1.vote_processor.flush (); node1.block_processor.flush (); @@ -882,7 +882,7 @@ TEST (active_transactions, fork_replacement_tally) .build_shared (); node1.process_active (open); // Confirmation - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ send->hash (), open->hash () })); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send, open }); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); } ASSERT_TIMELY_EQ (5s, node1.ledger.cache.cemented_count, 1 + 2 * reps_count); @@ -1082,7 +1082,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - auto vote_fork (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ fork->hash () })); + auto vote_fork = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code); ASSERT_TIMELY_EQ (5s, 1, node.active.size ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 4ef62f346f..7cee7d7cbe 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2520,7 +2520,7 @@ TEST (node, vote_republish) ASSERT_FALSE (node1.block (send2->hash ())); // the vote causes the election to reach quorum and for the vote (and block?) to be published from node1 to node2 - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ send2->hash () })); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send2 }); node1.vote_processor.vote (vote, std::make_shared (node1)); // FIXME: there is a race condition here, if the vote arrives before the block then the vote is wasted and the test fails @@ -2637,7 +2637,7 @@ TEST (node, vote_by_hash_republish) // construct a vote for send2 in order to overturn send1 std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, vote_blocks); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { vote_blocks }); node1.vote_processor.vote (vote, std::make_shared (node1)); // send2 should win on both nodes @@ -3150,7 +3150,7 @@ TEST (node, confirm_back) ASSERT_EQ (3, node.active.size ()); std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, vote_blocks)); + auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { vote_blocks }); node.vote_processor.vote_blocking (vote, std::make_shared (node)); ASSERT_TIMELY (10s, node.active.empty ()); } From 7934881705d8f7958835942a1317918f94c44b98 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Sat, 27 Jan 2024 19:49:52 +0700 Subject: [PATCH 041/190] Fix unit test node.search_receivable_confirmed (#4408) --- nano/core_test/node.cpp | 23 +++++++++-------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 7cee7d7cbe..1b9a1edb4e 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -419,30 +419,25 @@ TEST (node, search_receivable_confirmed) auto node = system.add_node (node_config); nano::keypair key2; system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); + ASSERT_TIMELY (5s, nano::test::confirmed (*node, { send1 })); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); - ASSERT_TIMELY (10s, node->active.empty ()); - bool confirmed (false); - system.deadline_set (5s); - while (!confirmed) - { - auto transaction (node->store.tx_begin_read ()); - confirmed = node->ledger.block_confirmed (transaction, send2->hash ()); - ASSERT_NO_ERROR (system.poll ()); - } + ASSERT_TIMELY (5s, nano::test::confirmed (*node, { send2 })); + { auto transaction (node->wallets.tx_begin_write ()); system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub); } + system.wallet (0)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (0)->search_receivable (system.wallet (0)->wallets.tx_begin_read ())); - { - ASSERT_FALSE (node->active.active (send1->hash ())); - ASSERT_FALSE (node->active.active (send2->hash ())); - } - ASSERT_TIMELY_EQ (10s, node->balance (key2.pub), 2 * node->config.receive_minimum.number ()); + ASSERT_TIMELY (5s, !node->active.active (send1->hash ())); + ASSERT_TIMELY (5s, !node->active.active (send2->hash ())); + ASSERT_TIMELY_EQ (5s, node->balance (key2.pub), 2 * node->config.receive_minimum.number ()); } TEST (node, search_receivable_pruned) From c58ec87dcd54751c521ef173137f5dd27acf4893 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Sun, 28 Jan 2024 00:48:56 +0700 Subject: [PATCH 042/190] Fix unit test active_transactions.vote_replays (#4401) --- nano/core_test/active_transactions.cpp | 31 +++++++++++++++++--------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 403b37ae04..a5ab31b488 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -555,6 +555,8 @@ TEST (active_transactions, vote_replays) auto & node = *system.add_node (node_config); nano::keypair key; nano::state_block_builder builder; + + // send Gxrb_ratio raw from genesis to key auto send1 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -565,6 +567,8 @@ TEST (active_transactions, vote_replays) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_NE (nullptr, send1); + + // create open block for key receing Gxrb_ratio raw auto open1 = builder.make_block () .account (key.pub) .previous (0) @@ -575,26 +579,31 @@ TEST (active_transactions, vote_replays) .work (*system.work.generate (key.pub)) .build_shared (); ASSERT_NE (nullptr, open1); + + // wait for elections objects to appear in the AEC node.process_active (send1); node.process_active (open1); ASSERT_TRUE (nano::test::start_elections (system, node, { send1, open1 })); ASSERT_EQ (2, node.active.size ()); + // First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed auto vote_send1 = nano::test::make_final_vote (nano::dev::genesis_key, { send1 }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1)); - ASSERT_EQ (2, node.active.size ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); + // Wait until the election is removed, at which point the vote is still a replay since it's been recently confirmed - ASSERT_TIMELY_EQ (3s, node.active.size (), 1); + ASSERT_TIMELY_EQ (5s, node.active.size (), 1); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); + // Open new account auto vote_open1 = nano::test::make_final_vote (nano::dev::genesis_key, { open1 }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1)); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); - ASSERT_TIMELY (3s, node.active.empty ()); + ASSERT_TIMELY (5s, node.active.empty ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_EQ (nano::Gxrb_ratio, node.ledger.weight (key.pub)); + // send 1 raw to key to key auto send2 = builder.make_block () .account (key.pub) .previous (open1->hash ()) @@ -608,17 +617,19 @@ TEST (active_transactions, vote_replays) node.process_active (send2); ASSERT_TRUE (nano::test::start_elections (system, node, { send2 })); ASSERT_EQ (1, node.active.size ()); + + // vote2_send2 is a non final vote with little weight, vote1_send2 is the vote that confirms the election auto vote1_send2 = nano::test::make_final_vote (nano::dev::genesis_key, { send2 }); - auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, 0, std::vector{ send2->hash () })); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2)); + auto vote2_send2 = nano::test::make_vote (key, { send2 }, 0, 0); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2)); // this vote cannot confirm the election ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2)); - ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote1_send2)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2)); // this vote cannot confirm the election ASSERT_EQ (1, node.active.size ()); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote1_send2)); // this vote confirms the election + + // this should still return replay, either because the election is still in the AEC or because it is recently confirmed ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2)); - ASSERT_TIMELY (3s, node.active.empty ()); - ASSERT_EQ (0, node.active.size ()); + ASSERT_TIMELY (5s, node.active.empty ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2)); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2)); From 244e49c6f7682f9f535ffcb0f52dfdd1e18066d0 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Tue, 30 Jan 2024 07:06:48 +0100 Subject: [PATCH 043/190] Set maximum unchecked blocks in config (#4342) Set maximum unchecked blocks in config --- nano/core_test/block_store.cpp | 3 ++- nano/core_test/toml.cpp | 3 +++ nano/core_test/unchecked_map.cpp | 14 ++++++++------ nano/node/node.cpp | 2 +- nano/node/nodeconfig.cpp | 3 +++ nano/node/nodeconfig.hpp | 1 + nano/node/unchecked_map.cpp | 6 ++++-- nano/node/unchecked_map.hpp | 5 ++--- 8 files changed, 24 insertions(+), 13 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index fe6d90c40c..4e622a2beb 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -436,7 +436,8 @@ TEST (block_store, empty_bootstrap) { nano::test::system system{}; nano::logger logger; - nano::unchecked_map unchecked{ system.stats, false }; + unsigned max_unchecked_blocks = 65536; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; size_t count = 0; unchecked.for_each ([&count] (nano::unchecked_key const & key, nano::unchecked_info const & info) { ++count; diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index b28c875750..4e13e7b422 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -193,6 +193,7 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.work_peers, defaults.node.work_peers); ASSERT_EQ (conf.node.work_threads, defaults.node.work_threads); ASSERT_EQ (conf.node.max_queued_requests, defaults.node.max_queued_requests); + ASSERT_EQ (conf.node.max_unchecked_blocks, defaults.node.max_unchecked_blocks); ASSERT_EQ (conf.node.backlog_scan_batch_size, defaults.node.backlog_scan_batch_size); ASSERT_EQ (conf.node.backlog_scan_frequency, defaults.node.backlog_scan_frequency); @@ -421,6 +422,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) work_threads = 999 max_work_generate_multiplier = 1.0 max_queued_requests = 999 + max_unchecked_blocks = 999 frontiers_confirmation = "always" backlog_scan_batch_size = 999 backlog_scan_frequency = 999 @@ -585,6 +587,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.external_port, defaults.node.external_port); ASSERT_NE (conf.node.io_threads, defaults.node.io_threads); ASSERT_NE (conf.node.max_work_generate_multiplier, defaults.node.max_work_generate_multiplier); + ASSERT_NE (conf.node.max_unchecked_blocks, defaults.node.max_unchecked_blocks); ASSERT_NE (conf.node.frontiers_confirmation, defaults.node.frontiers_confirmation); ASSERT_NE (conf.node.network_threads, defaults.node.network_threads); ASSERT_NE (conf.node.background_threads, defaults.node.background_threads); diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 6823c1f72d..6b3c799652 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -14,11 +14,13 @@ using namespace std::chrono_literals; namespace { +unsigned max_unchecked_blocks = 65536; + class context { public: context () : - unchecked{ stats, false } + unchecked{ max_unchecked_blocks, stats, false } { } nano::stats stats; @@ -54,7 +56,7 @@ TEST (unchecked_map, put_one) TEST (block_store, one_bootstrap) { nano::test::system system{}; - nano::unchecked_map unchecked{ system.stats, false }; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; nano::block_builder builder; auto block1 = builder .send () @@ -87,7 +89,7 @@ TEST (block_store, one_bootstrap) TEST (unchecked, simple) { nano::test::system system{}; - nano::unchecked_map unchecked{ system.stats, false }; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; nano::block_builder builder; auto block = builder .send () @@ -128,7 +130,7 @@ TEST (unchecked, multiple) // Don't test this in rocksdb mode GTEST_SKIP (); } - nano::unchecked_map unchecked{ system.stats, false }; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; nano::block_builder builder; auto block = builder .send () @@ -158,7 +160,7 @@ TEST (unchecked, multiple) TEST (unchecked, double_put) { nano::test::system system{}; - nano::unchecked_map unchecked{ system.stats, false }; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; nano::block_builder builder; auto block = builder .send () @@ -189,7 +191,7 @@ TEST (unchecked, double_put) TEST (unchecked, multiple_get) { nano::test::system system{}; - nano::unchecked_map unchecked{ system.stats, false }; + nano::unchecked_map unchecked{ max_unchecked_blocks, system.stats, false }; // Instantiates three blocks nano::block_builder builder; auto block1 = builder diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 399fe821b9..cb854c326f 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -153,7 +153,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons distributed_work (*this), store_impl (nano::make_store (logger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), store (*store_impl), - unchecked{ stats, flags.disable_block_processor_unchecked_deletion }, + unchecked{ config.max_unchecked_blocks, stats, flags.disable_block_processor_unchecked_deletion }, wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), wallets_store (*wallets_store_impl), gap_cache (*this), diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 61179c685c..175d78477b 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -128,6 +128,7 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const toml.put ("max_work_generate_multiplier", max_work_generate_multiplier, "Maximum allowed difficulty multiplier for work generation.\ntype:double,[1..]"); toml.put ("frontiers_confirmation", serialize_frontiers_confirmation (frontiers_confirmation), "Mode controlling frontier confirmation rate.\ntype:string,{auto,always,disabled}"); toml.put ("max_queued_requests", max_queued_requests, "Limit for number of queued confirmation requests for one channel, after which new requests are dropped until the queue drops below this value.\ntype:uint32"); + toml.put ("max_unchecked_blocks", max_unchecked_blocks, "Maximum number of unchecked blocks to store in memory. Defaults to 65536. \ntype:uint64,[0..]"); toml.put ("rep_crawler_weight_minimum", rep_crawler_weight_minimum.to_string_dec (), "Rep crawler minimum weight, if this is less than minimum principal weight then this is taken as the minimum weight a rep must have to be tracked. If you want to track all reps set this to 0. If you do not want this to influence anything then set it to max value. This is only useful for debugging or for people who really know what they are doing.\ntype:string,amount,raw"); toml.put ("backlog_scan_batch_size", backlog_scan_batch_size, "Number of accounts per second to process when doing backlog population scan. Increasing this value will help unconfirmed frontiers get into election prioritization queue faster, however it will also increase resource usage. \ntype:uint"); toml.put ("backlog_scan_frequency", backlog_scan_frequency, "Backlog scan divides the scan into smaller batches, number of which is controlled by this value. Higher frequency helps to utilize resources more uniformly, however it also introduces more overhead. The resulting number of accounts per single batch is `backlog_scan_batch_size / backlog_scan_frequency` \ntype:uint"); @@ -415,6 +416,8 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) toml.get ("max_queued_requests", max_queued_requests); + toml.get ("max_unchecked_blocks", max_unchecked_blocks); + auto rep_crawler_weight_minimum_l (rep_crawler_weight_minimum.to_string_dec ()); if (toml.has_key ("rep_crawler_weight_minimum")) { diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index d1a42fa370..8f7580534a 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -116,6 +116,7 @@ class node_config bool backup_before_upgrade{ false }; double max_work_generate_multiplier{ 64. }; uint32_t max_queued_requests{ 512 }; + unsigned max_unchecked_blocks{ 65536 }; std::chrono::seconds max_pruning_age{ !network_params.network.is_beta_network () ? std::chrono::seconds (24 * 60 * 60) : std::chrono::seconds (5 * 60) }; // 1 day; 5 minutes for beta network uint64_t max_pruning_depth{ 0 }; nano::rocksdb_config rocksdb_config; diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index 45d3b49563..b20651d793 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -5,7 +5,8 @@ #include #include -nano::unchecked_map::unchecked_map (nano::stats & stats, bool const & disable_delete) : +nano::unchecked_map::unchecked_map (unsigned const max_unchecked_blocks, nano::stats & stats, bool const & disable_delete) : + max_unchecked_blocks{ max_unchecked_blocks }, stats{ stats }, disable_delete{ disable_delete }, thread{ [this] () { run (); } } @@ -23,7 +24,8 @@ void nano::unchecked_map::put (nano::hash_or_account const & dependency, nano::u nano::lock_guard lock{ entries_mutex }; nano::unchecked_key key{ dependency, info.block->hash () }; entries.get ().insert ({ key, info }); - if (entries.size () > mem_block_count_max) + + if (entries.size () > max_unchecked_blocks) { entries.get ().pop_front (); } diff --git a/nano/node/unchecked_map.hpp b/nano/node/unchecked_map.hpp index b76e8ccb44..9a548c203d 100644 --- a/nano/node/unchecked_map.hpp +++ b/nano/node/unchecked_map.hpp @@ -22,7 +22,7 @@ class stats; class unchecked_map { public: - unchecked_map (nano::stats &, bool const & do_delete); + unchecked_map (unsigned const max_unchecked_blocks, nano::stats &, bool const & do_delete); ~unchecked_map (); void put (nano::hash_or_account const & dependency, nano::unchecked_info const & info); @@ -62,11 +62,10 @@ class unchecked_map nano::condition_variable condition; nano::mutex mutex; std::thread thread; + unsigned const max_unchecked_blocks; void process_queries (decltype (buffer) const & back_buffer); - static std::size_t constexpr mem_block_count_max = 64 * 1024; - private: struct entry { From 449c87399dd1d26adb66bda38c263876419ee8b4 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Tue, 30 Jan 2024 16:59:36 +0100 Subject: [PATCH 044/190] Use the make_vote function in unit tests (#4410) --- nano/core_test/active_transactions.cpp | 10 +++++----- nano/core_test/conflicts.cpp | 6 +++--- nano/core_test/ledger.cpp | 20 ++++++++++---------- nano/core_test/message.cpp | 4 ++-- nano/core_test/network.cpp | 4 ++-- nano/core_test/node.cpp | 8 ++++---- nano/core_test/vote_processor.cpp | 6 +++--- nano/core_test/websocket.cpp | 2 +- nano/rpc_test/rpc.cpp | 2 +- 9 files changed, 31 insertions(+), 31 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index a5ab31b488..74e3250871 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -362,7 +362,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) ASSERT_NE (nullptr, election); ASSERT_GT (node.weight (key.pub), node.minimum_principal_weight ()); // Insert vote - auto vote1 (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector (1, send->hash ()))); + auto vote1 = nano::test::make_vote (key, { send }, nano::vote::timestamp_min * 1, 0); node.vote_processor.vote (vote1, std::make_shared (node, node)); ASSERT_TIMELY_EQ (5s, election->votes ().size (), 2); ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_new)); @@ -425,10 +425,10 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) ASSERT_TIMELY (5s, nano::test::exists (node, { send1, send2, open })); // Process votes - auto vote1 (std::make_shared (key1.pub, key1.prv, 0, 0, std::vector (1, send1->hash ()))); + auto vote1 = nano::test::make_vote (key1, { send1 }, 0, 0); node.vote_processor.vote (vote1, std::make_shared (node, node)); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send1->hash ()))); + auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); node.vote_processor.vote (vote2, std::make_shared (node, node)); ASSERT_TIMELY (5s, node.vote_cache.find (send1->hash ())); @@ -941,7 +941,7 @@ TEST (active_transactions, fork_replacement_tally) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (keys[i].pub, keys[i].prv, 0, 0, std::vector{ fork->hash () })); + auto vote = nano::test::make_vote (keys[i], { fork }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); node1.vote_processor.flush (); node1.process_active (fork); @@ -986,7 +986,7 @@ TEST (active_transactions, fork_replacement_tally) ASSERT_FALSE (blocks1.find (send_last->hash ()) != blocks1.end ()); // Process vote for correct block & replace existing lowest tally block - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ send_last->hash () })); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { send_last }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); node1.vote_processor.flush (); // ensure vote arrives before the block diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 4232edb429..3a74dfaf70 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -152,7 +152,7 @@ TEST (vote_uniquer, vbh_one) .build_shared (); std::vector hashes; hashes.push_back (block->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes)); + auto vote1 = nano::test::make_vote (key, { hashes }, 0, 0); auto vote2 (std::make_shared (*vote1)); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote1, uniquer.unique (vote2)); @@ -187,8 +187,8 @@ TEST (vote_uniquer, vbh_two) .build_shared (); std::vector hashes2; hashes2.push_back (block2->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes1)); - auto vote2 (std::make_shared (key.pub, key.prv, 0, 0, hashes2)); + auto vote1 = nano::test::make_vote (key, { hashes1 }, 0, 0); + auto vote2 = nano::test::make_vote (key, { hashes2 }, 0, 0); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote2, uniquer.unique (vote2)); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index efe7a05ab0..88f7c6d756 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -919,7 +919,7 @@ TEST (votes, check_signature) ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 1, 0); vote1->signature.bytes[0] ^= 1; ASSERT_EQ (nano::vote_code::invalid, node1.vote_processor.vote_blocking (vote1, std::make_shared (node1, node1))); vote1->signature.bytes[0] ^= 1; @@ -948,9 +948,9 @@ TEST (votes, add_one) ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 1, 0); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send1->hash () })); + auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 2, 0); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_EQ (2, election1->votes ().size ()); auto votes1 (election1->votes ()); @@ -989,7 +989,7 @@ TEST (votes, add_existing) node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 1, 0); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); // Block is already processed from vote ASSERT_TRUE (node1.active.publish (send1)); @@ -1007,7 +1007,7 @@ TEST (votes, add_existing) node1.work_generate_blocking (*send2); ASSERT_FALSE (node1.active.publish (send2)); ASSERT_TIMELY (5s, node1.active.active (*send2)); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send2->hash () })); + auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send2 }, nano::vote::timestamp_min * 2, 0); // Pretend we've waited the timeout auto vote_info1 = election1->get_last_vote (nano::dev::genesis_key.pub); vote_info1.time = std::chrono::steady_clock::now () - std::chrono::seconds (20); @@ -1048,7 +1048,7 @@ TEST (votes, add_old) node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 2, 0); auto channel (std::make_shared (node1, node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; @@ -1111,13 +1111,13 @@ TEST (votes, DISABLED_add_old_different_account) ASSERT_NE (nullptr, election2); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 2, 0); auto channel (std::make_shared (node1, node1)); auto vote_result1 (node1.vote_processor.vote_blocking (vote1, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result1); ASSERT_EQ (2, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send2->hash () })); + auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send2 }, nano::vote::timestamp_min * 1, 0); auto vote_result2 (node1.vote_processor.vote_blocking (vote2, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result2); ASSERT_EQ (2, election1->votes ().size ()); @@ -1153,7 +1153,7 @@ TEST (votes, add_cooldown) node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send1->hash () })); + auto vote1 = nano::test::make_vote (nano::dev::genesis_key, { send1 }, nano::vote::timestamp_min * 1, 0); auto channel (std::make_shared (node1, node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; @@ -1166,7 +1166,7 @@ TEST (votes, add_cooldown) .work (0) .build_shared (); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send2->hash () })); + auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send2 }, nano::vote::timestamp_min * 2, 0); node1.vote_processor.vote_blocking (vote2, channel); ASSERT_EQ (2, election1->votes ().size ()); auto votes (election1->votes ()); diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index c26e359a45..024cf03f7f 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -165,7 +165,7 @@ TEST (message, confirm_ack_hash_serialization) hashes.push_back (block->hash ()); } nano::keypair representative1; - auto vote (std::make_shared (representative1.pub, representative1.prv, 0, 0, hashes)); + auto vote = nano::test::make_vote (representative1, { hashes }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { @@ -206,7 +206,7 @@ TEST (message, confirm_ack_hash_serialization_v2) } nano::keypair representative1; - auto vote (std::make_shared (representative1.pub, representative1.prv, 0, 0, hashes)); + auto vote = nano::test::make_vote (representative1, { hashes }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index fdc49ccd8d..d2ab36df39 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -369,7 +369,7 @@ TEST (receivable_processor, confirm_insufficient_pos) ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; - auto vote (std::make_shared (key1.pub, key1.prv, 0, 0, std::vector{ block1->hash () })); + auto vote = nano::test::make_vote (key1, { block1 }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; auto channel1 = std::make_shared (node1, node1); node1.network.inbound (con1, channel1); @@ -391,7 +391,7 @@ TEST (receivable_processor, confirm_sufficient_pos) node1.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ block1->hash () })); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; auto channel1 = std::make_shared (node1, node1); node1.network.inbound (con1, channel1); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 1b9a1edb4e..a007a3bed3 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2461,7 +2461,7 @@ TEST (node, local_votes_cache_fork) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); // Cache vote - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send1->hash ()))); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.history.add (send1->root (), send1->hash (), vote); auto votes2 (node1.history.votes (send1->root (), send1->hash ())); @@ -2675,7 +2675,7 @@ TEST (node, DISABLED_vote_by_hash_epoch_block_republish) node1.active.publish (epoch1); std::vector vote_blocks; vote_blocks.push_back (epoch1->hash ()); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, vote_blocks)); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { vote_blocks }, 0, 0); ASSERT_TRUE (node1.active.active (*send1)); ASSERT_TRUE (node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -2810,8 +2810,8 @@ TEST (node, DISABLED_fork_invalid_block_signature) .build_shared (); auto send2_corrupt (std::make_shared (*send2)); send2_corrupt->signature = nano::signature (123); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ send2->hash () })); - auto vote_corrupt (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ send2_corrupt->hash () })); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { send2 }, 0, 0); + auto vote_corrupt = nano::test::make_vote (nano::dev::genesis_key, { send2_corrupt }, 0, 0); node1.process_active (send1); ASSERT_TIMELY (5s, node1.block (send1->hash ())); diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 210db3cd17..bd33093ac3 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -14,7 +14,7 @@ TEST (vote_processor, codes) nano::test::system system (1); auto & node (*system.nodes[0]); auto blocks = nano::test::setup_chain (system, node, 1, nano::dev::genesis_key, false); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ blocks[0]->hash () })); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { blocks[0] }, nano::vote::timestamp_min * 1, 0); auto vote_invalid = std::make_shared (*vote); vote_invalid->signature.bytes[0] ^= 1; auto channel (std::make_shared (node, node)); @@ -90,7 +90,7 @@ TEST (vote_processor, no_capacity) node_flags.vote_processor_capacity = 0; auto & node (*system.add_node (node_flags)); nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () })); + auto vote = nano::test::make_vote (key, { nano::dev::genesis }, nano::vote::timestamp_min * 1, 0); auto channel (std::make_shared (node, node)); ASSERT_TRUE (node.vote_processor.vote (vote, channel)); } @@ -102,7 +102,7 @@ TEST (vote_processor, overflow) node_flags.vote_processor_capacity = 1; auto & node (*system.add_node (node_flags)); nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () })); + auto vote = nano::test::make_vote (key, { nano::dev::genesis }, nano::vote::timestamp_min * 1, 0); auto channel (std::make_shared (node, node)); auto start_time = std::chrono::system_clock::now (); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index f069c6539c..5a010d684d 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -673,7 +673,7 @@ TEST (websocket, vote_options_type) ASSERT_TIMELY (5s, ack_ready); // Custom made votes for simplicity - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () })); + auto vote = nano::test::make_vote (nano::dev::genesis_key, { nano::dev::genesis }, 0, 0); nano::websocket::message_builder builder; auto msg (builder.vote_received (vote, nano::vote_code::replay)); node1->websocket.server->broadcast (msg); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 166f5e6cc9..291e0036fd 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -5803,7 +5803,7 @@ TEST (rpc, memory_stats) .build_shared (); std::vector hashes; hashes.push_back (block->hash ()); - auto vote (std::make_shared (key.pub, key.prv, 0, 0, hashes)); + auto vote = nano::test::make_vote (key, { hashes }, 0, 0); node->vote_uniquer.unique (vote); boost::property_tree::ptree request; request.put ("action", "stats"); From 9c2e7d85cfd01be452f09f7ebaec2246c16e969e Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 30 Jan 2024 19:46:22 +0000 Subject: [PATCH 045/190] Clean up node.fork_multi_flip test. Previously it was inserting blocks using network messages which allowed a race condition between block gossip and the test inserting the forked blocks in to the second test node. This directly inserts blocks with ledger.process which removes the race condition. (#4411) --- nano/core_test/node.cpp | 46 +++++++++++++---------------------------- 1 file changed, 14 insertions(+), 32 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index a007a3bed3..36470a63ca 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -752,6 +752,7 @@ TEST (node, fork_flip) ASSERT_FALSE (node2.ledger.block_or_pruned_exists (publish2.block->hash ())); } +// Test that more than one block can be rolled back TEST (node, fork_multi_flip) { auto type = nano::transport::transport_type::tcp; @@ -772,7 +773,6 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) @@ -781,44 +781,26 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish2{ nano::dev::network_params.network, send2 }; auto send3 = builder.make_block () - .previous (publish2.block->hash ()) + .previous (send2->hash ()) .destination (key2.pub) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (publish2.block->hash ())) + .work (*system.work.generate (send2->hash ())) .build_shared (); - nano::publish publish3{ nano::dev::network_params.network, send3 }; - auto channel1 = std::make_shared (node1); - auto channel2 = std::make_shared (node2); - node1.network.inbound (publish1, channel1); - node2.network.inbound (publish2, channel2); - node2.network.inbound (publish3, channel2); - node1.block_processor.flush (); - node2.block_processor.flush (); - ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); - ASSERT_TIMELY_EQ (5s, 1, node2.active.size ()); - system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); + // Node2 has two blocks that will be rolled back by node1's vote + ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3).code); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1 - node1.network.inbound (publish2, channel1); - node1.network.inbound (publish3, channel1); - node1.block_processor.flush (); - node2.network.inbound (publish1, channel2); - node2.block_processor.flush (); - ASSERT_TIMELY (5s, node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); - auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); - ASSERT_NE (nullptr, election1); - ASSERT_EQ (1, election1->votes ().size ()); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); - ASSERT_TRUE (nano::test::block_or_pruned_all_exists (node2, { publish2.block, publish3.block })); - ASSERT_TIMELY (10s, node2.ledger.block_or_pruned_exists (publish1.block->hash ())); - auto winner (*election1->tally ().begin ()); - ASSERT_EQ (*publish1.block, *winner.second); + auto election = nano::test::start_election (system, node2, send2->hash ()); + ASSERT_NE (nullptr, election); + ASSERT_TIMELY (5s, node2.ledger.block_or_pruned_exists (send1->hash ())); + ASSERT_TRUE (nano::test::block_or_pruned_none_exists (node2, { send2, send3 })); + auto winner = *election->tally ().begin (); + ASSERT_EQ (*send1, *winner.second); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish1.block->hash ())); - ASSERT_TRUE (nano::test::block_or_pruned_none_exists (node2, { publish2.block, publish3.block })); } // Blocks that are no longer actively being voted on should be able to be evicted through bootstrapping. From cf844c583a8a732fbbffc40ccb59136729d8ef63 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 25 Jan 2024 23:41:23 +0000 Subject: [PATCH 046/190] Removing calls to flush that already have ASSERT_TIMELY checks immediately after. --- nano/core_test/active_transactions.cpp | 8 ++------ nano/core_test/confirmation_height.cpp | 5 +---- nano/core_test/gap_cache.cpp | 1 - nano/core_test/node.cpp | 8 -------- nano/core_test/websocket.cpp | 3 +-- 5 files changed, 4 insertions(+), 21 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 74e3250871..dbbb32cf7a 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -255,7 +255,6 @@ TEST (active_transactions, inactive_votes_cache) node.vote_processor.vote (vote, std::make_shared (node, node)); ASSERT_TIMELY_EQ (5s, node.vote_cache.size (), 1); node.process_active (send); - node.block_processor.flush (); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send->hash ())); ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached)); } @@ -356,7 +355,6 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) .build_shared (); node.process_active (send); node.block_processor.add (open); - node.block_processor.flush (); ASSERT_TIMELY_EQ (5s, node.active.size (), 1); auto election (node.active.election (send->qualified_root ())); ASSERT_NE (nullptr, election); @@ -725,7 +723,7 @@ TEST (active_transactions, republish_winner) .build_shared (); node1.process_active (send1); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (node1, { send1 })); ASSERT_TIMELY_EQ (3s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in), 1); // Several forks @@ -741,8 +739,8 @@ TEST (active_transactions, republish_winner) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (fork); + ASSERT_TIMELY (5s, node1.active.active (*fork)); } - node1.block_processor.flush (); ASSERT_TIMELY (3s, !node1.active.empty ()); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); @@ -764,7 +762,6 @@ TEST (active_transactions, republish_winner) auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); node1.vote_processor.flush (); - node1.block_processor.flush (); ASSERT_TIMELY (5s, election->confirmed ()); ASSERT_EQ (fork->hash (), election->status.winner->hash ()); ASSERT_TIMELY (5s, node2.block_confirmed (fork->hash ())); @@ -1055,7 +1052,6 @@ TEST (active_transactions, DISABLED_confirm_new) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send); - node1.block_processor.flush (); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); auto & node2 = *system.add_node (); // Add key to node2 diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 2271e4985c..15b6aa633d 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -61,8 +61,7 @@ TEST (confirmation_height, single) ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); node->process_active (send1); - node->block_processor.flush (); - + ASSERT_TIMELY (5s, nano::test::exists (*node, { send1 })); ASSERT_TIMELY_EQ (10s, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out), 1); { @@ -538,7 +537,6 @@ TEST (confirmation_height, gap_live) // Now complete the chain where the block comes in on the live network node->process_active (open1); - node->block_processor.flush (); ASSERT_TIMELY_EQ (10s, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out), 6); @@ -1220,7 +1218,6 @@ TEST (confirmation_height, observers) add_callback_stats (*node1); node1->process_active (send1); - node1->block_processor.flush (); ASSERT_TIMELY_EQ (10s, node1->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out), 1); auto transaction = node1->store.tx_begin_read (); ASSERT_TRUE (node1->ledger.block_confirmed (transaction, send1->hash ())); diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp index 7b6924e396..360e2ce2ea 100644 --- a/nano/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -163,7 +163,6 @@ TEST (gap_cache, two_dependencies) node1.block_processor.flush (); ASSERT_EQ (2, node1.gap_cache.size ()); node1.block_processor.add (send1); - node1.block_processor.flush (); ASSERT_TIMELY_EQ (5s, node1.gap_cache.size (), 0); ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), send2->hash ())); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 36470a63ca..5ba5b9e296 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -575,7 +575,6 @@ TEST (node, fork_publish) .build_shared (); node1.work_generate_blocking (*send2); node1.process_active (send1); - node1.block_processor.flush (); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); auto election (node1.active.election (send1->qualified_root ())); ASSERT_NE (nullptr, election); @@ -673,9 +672,7 @@ TEST (node, fork_keep) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); - node1.block_processor.flush (); node2.process_active (send1); - node2.block_processor.flush (); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); ASSERT_TIMELY_EQ (5s, 1, node2.active.size ()); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -728,9 +725,7 @@ TEST (node, fork_flip) auto ignored_channel{ std::make_shared (node1, std::weak_ptr ()) }; node1.network.inbound (publish1, ignored_channel); - node1.block_processor.flush (); node2.network.inbound (publish2, ignored_channel); - node2.block_processor.flush (); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); ASSERT_TIMELY_EQ (5s, 1, node2.active.size ()); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -2083,7 +2078,6 @@ TEST (node, online_reps_election) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); - node1.block_processor.flush (); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); // Process vote for ongoing election auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), 0, std::vector{ send1->hash () }); @@ -2453,7 +2447,6 @@ TEST (node, local_votes_cache_fork) node_config.peering_port = system.get_available_port (); auto & node2 (*system.add_node (node_config, node_flags)); node2.process_active (send1_fork); - node2.block_processor.flush (); ASSERT_TIMELY (5s, node2.ledger.block_or_pruned_exists (send1->hash ())); } @@ -3337,7 +3330,6 @@ TEST (node, bidirectional_tcp) .work (*node1->work_generate_blocking (send1->hash ())) .build_shared (); node2->process_active (send2); - node2->block_processor.flush (); ASSERT_TIMELY (10s, node1->ledger.block_or_pruned_exists (send2->hash ()) && node2->ledger.block_or_pruned_exists (send2->hash ())); // Test block confirmation from node 2 (add representative to node 2) system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 5a010d684d..fb88af4901 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -210,8 +210,7 @@ TEST (websocket, stopped_election) nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 = std::make_shared (*node1); node1->network.inbound (publish1, channel1); - node1->block_processor.flush (); - ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); + ASSERT_TIMELY (5s, node1->active.election (send1->qualified_root ())); node1->active.erase (*send1); ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready); From b187757f5ba729d56e4941772e819f7d437703ff Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 26 Jan 2024 16:08:29 +0000 Subject: [PATCH 047/190] Replace block_processor::flush in unit tests with an equivalent ASSERT_TIMELY for the expected behaviour for the test. --- nano/core_test/active_transactions.cpp | 8 +++----- nano/core_test/confirmation_height.cpp | 6 ++++-- nano/core_test/gap_cache.cpp | 6 ++---- nano/core_test/network.cpp | 4 ++-- nano/core_test/node.cpp | 15 ++++++++------- nano/core_test/wallet.cpp | 4 ++-- 6 files changed, 21 insertions(+), 22 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index dbbb32cf7a..910a518cb9 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -756,7 +756,7 @@ TEST (active_transactions, republish_winner) .build_shared (); node1.process_active (fork); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, node1.active.active (fork->hash ())); auto election = node1.active.election (fork->qualified_root ()); ASSERT_NE (nullptr, election); auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); @@ -974,12 +974,10 @@ TEST (active_transactions, fork_replacement_tally) node1.network.publish_filter.clear (); node2.network.flood_block (send_last); ASSERT_TIMELY (3s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) > 0); - node1.block_processor.flush (); - system.delay_ms (50ms); // Correct block without votes is ignored - auto blocks1 (election->blocks ()); - ASSERT_EQ (max_blocks, blocks1.size ()); + std::unordered_map> blocks1; + ASSERT_TIMELY_EQ (5s, max_blocks, (blocks1 = election->blocks (), blocks1.size ())); ASSERT_FALSE (blocks1.find (send_last->hash ()) != blocks1.end ()); // Process vote for correct block & replace existing lowest tally block diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 15b6aa633d..fb8b97c3f1 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -513,14 +513,16 @@ TEST (confirmation_height, gap_live) node->block_processor.add (send1); node->block_processor.add (send2); node->block_processor.add (send3); + // node->block_processor.add (open1); Witheld for test node->block_processor.add (receive1); - node->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*node, { send1, send2, send3 })); + ASSERT_TIMELY (5s, node->unchecked.exists ({ open1->hash (), receive1->hash () })); add_callback_stats (*node); // Receive 2 comes in on the live network, however the chain has not been finished so it gets added to unchecked node->process_active (receive2); - node->block_processor.flush (); + ASSERT_TIMELY (5s, node->unchecked.exists ({ receive1->hash (), receive2->hash () })); // Confirmation heights should not be updated { diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp index 360e2ce2ea..561088db11 100644 --- a/nano/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -157,11 +157,9 @@ TEST (gap_cache, two_dependencies) .build_shared (); ASSERT_EQ (0, node1.gap_cache.size ()); node1.block_processor.add (send2); - node1.block_processor.flush (); - ASSERT_EQ (1, node1.gap_cache.size ()); + ASSERT_TIMELY_EQ (5s, 1, node1.gap_cache.size ()); node1.block_processor.add (open); - node1.block_processor.flush (); - ASSERT_EQ (2, node1.gap_cache.size ()); + ASSERT_TIMELY_EQ (5s, 2, node1.gap_cache.size ()); node1.block_processor.add (send1); ASSERT_TIMELY_EQ (5s, node1.gap_cache.size (), 0); ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), send1->hash ())); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index d2ab36df39..acdc87d43f 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -423,9 +423,9 @@ TEST (receivable_processor, send_with_receive) ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node2.balance (key2.pub)); node1.process_active (block1); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (node1, { block1 })); node2.process_active (block1); - node2.block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (node2, { block1 })); ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.balance (key2.pub)); ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub)); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 5ba5b9e296..3f081f9f49 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -355,8 +355,7 @@ TEST (node, receive_gap) nano::publish message{ nano::dev::network_params.network, block }; auto channel1 = std::make_shared (node1); node1.network.inbound (message, channel1); - node1.block_processor.flush (); - ASSERT_EQ (1, node1.gap_cache.size ()); + ASSERT_TIMELY_EQ (5s, 1, node1.gap_cache.size ()); } TEST (node, merge_peers) @@ -581,7 +580,7 @@ TEST (node, fork_publish) // Wait until the genesis rep activated & makes vote ASSERT_TIMELY_EQ (1s, election->votes ().size (), 2); node1.process_active (send2); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, node1.active.active (*send2)); auto votes1 (election->votes ()); auto existing1 (votes1.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes1.end (), existing1); @@ -676,10 +675,11 @@ TEST (node, fork_keep) ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); ASSERT_TIMELY_EQ (5s, 1, node2.active.size ()); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + // Fill node with forked blocks node1.process_active (send2); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, node1.active.active (*send2)); node2.process_active (send2); - node2.block_processor.flush (); + ASSERT_TIMELY (5s, node2.active.active (*send2)); auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); @@ -729,10 +729,11 @@ TEST (node, fork_flip) ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); ASSERT_TIMELY_EQ (5s, 1, node2.active.size ()); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + // Fill nodes with forked blocks node1.network.inbound (publish2, ignored_channel); - node1.block_processor.flush (); + ASSERT_TIMELY (5s, node1.active.active (*send2)); node2.network.inbound (publish1, ignored_channel); - node2.block_processor.flush (); + ASSERT_TIMELY (5s, node2.active.active (*send1)); auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index c27749522f..625dbb795a 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -946,7 +946,7 @@ TEST (wallet, change_seed) wallet->insert_adhoc (nano::dev::genesis_key.prv, false); auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100)); ASSERT_NE (nullptr, block); - system.nodes[0]->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*system.nodes[0], { block })); { auto transaction (wallet->wallets.tx_begin_write ()); wallet->change_seed (transaction, seed1); @@ -980,7 +980,7 @@ TEST (wallet, deterministic_restore) wallet->insert_adhoc (nano::dev::genesis_key.prv, false); auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100)); ASSERT_NE (nullptr, block); - system.nodes[0]->block_processor.flush (); + ASSERT_TIMELY (5s, nano::test::exists (*system.nodes[0], { block })); { auto transaction (wallet->wallets.tx_begin_write ()); wallet->deterministic_restore (transaction); From 299bfbc4c9173e60ec22a988ea305c9aebfe13f4 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 26 Jan 2024 16:47:10 +0000 Subject: [PATCH 048/190] Rewriting tests to not use block_processor::flush. --- nano/core_test/confirmation_height.cpp | 8 ++------ nano/core_test/node.cpp | 7 ++----- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index fb8b97c3f1..a57657b580 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1497,17 +1497,13 @@ TEST (confirmation_height, callback_confirmed_history) add_callback_stats (*node); node->process_active (send1); - ASSERT_NE (nano::test::start_election (system, *node, send1->hash ()), nullptr); + std::shared_ptr election; + ASSERT_TIMELY (5s, election = nano::test::start_election (system, *node, send1->hash ())); { - node->process_active (send); - node->block_processor.flush (); - // The write guard prevents the confirmation height processor doing any writes auto write_guard = node->write_database_queue.wait (nano::writer::testing); // Confirm send1 - auto election = node->active.election (send1->qualified_root ()); - ASSERT_NE (nullptr, election); election->force_confirm (); ASSERT_TIMELY_EQ (10s, node->active.size (), 0); ASSERT_EQ (0, node->active.recently_cemented.list ().size ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 3f081f9f49..68084f9236 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2971,8 +2971,7 @@ TEST (node, block_processor_reject_state) send1->signature.bytes[0] ^= 1; ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); node.process_active (send1); - auto flushed = std::async (std::launch::async, [&node] { node.block_processor.flush (); }); - ASSERT_NE (std::future_status::timeout, flushed.wait_for (5s)); + ASSERT_TIMELY_EQ (5s, 1, node.stats.count (nano::stat::type::blockprocessor, nano::stat::detail::bad_signature)); ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -2984,9 +2983,7 @@ TEST (node, block_processor_reject_state) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); node.process_active (send2); - auto flushed2 = std::async (std::launch::async, [&node] { node.block_processor.flush (); }); - ASSERT_NE (std::future_status::timeout, flushed2.wait_for (5s)); - ASSERT_TRUE (node.ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_TIMELY (5s, node.ledger.block_or_pruned_exists (send2->hash ())); } TEST (node, block_processor_full) From 701dbfd73f06a0a63d033ae24420602e010b4901 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 26 Jan 2024 17:38:13 +0000 Subject: [PATCH 049/190] Removing block_processor::flush from slow tests and command line operations. --- nano/nano_node/entry.cpp | 10 ++++------ nano/slow_test/node.cpp | 5 ++++- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index e77751762e..89cff93745 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -990,7 +990,6 @@ int main (int argc, char * const * argv) } } - node->block_processor.flush (); auto end (std::chrono::high_resolution_clock::now ()); auto time (std::chrono::duration_cast (end - begin).count ()); node->stop (); @@ -1083,7 +1082,10 @@ int main (int argc, char * const * argv) node->process_active (block); blocks.pop_front (); } - node->block_processor.flush (); + while (node->block_processor.size () > 0) + { + std::this_thread::sleep_for (std::chrono::milliseconds (100)); + } // Processing votes std::cerr << boost::str (boost::format ("Starting processing %1% votes\n") % max_votes); auto begin (std::chrono::high_resolution_clock::now ()); @@ -1191,7 +1193,6 @@ int main (int argc, char * const * argv) { node1->block_processor.add (block); } - node1->block_processor.flush (); auto iteration (0); while (node1->ledger.cache.block_count != count * 2 + 1) { @@ -1241,7 +1242,6 @@ int main (int argc, char * const * argv) node2->block_processor.add (block); blocks.pop_front (); } - node2->block_processor.flush (); while (node2->ledger.cache.block_count != count * 2 + 1) { std::this_thread::sleep_for (std::chrono::milliseconds (500)); @@ -1836,8 +1836,6 @@ int main (int argc, char * const * argv) } } - node.node->block_processor.flush (); - auto end (std::chrono::high_resolution_clock::now ()); auto time (std::chrono::duration_cast (end - begin).count ()); auto us_in_second (1000000); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 4310968dae..c36a60b4f9 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1887,7 +1887,10 @@ TEST (node, mass_block_new) } ASSERT_TIMELY_EQ (200s, node.ledger.cache.block_count, next_block_count); next_block_count += num_blocks; - node.block_processor.flush (); + while (node.block_processor.size () > 0) + { + std::this_thread::sleep_for (std::chrono::milliseconds{ 100 }); + } // Clear all active { nano::lock_guard guard{ node.active.mutex }; From 0ce4ed40b53600396c3a4af856a293003e151ee1 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 26 Jan 2024 17:55:08 +0000 Subject: [PATCH 050/190] Removing usage of block_processor::flush from bootstrap_legacy and removing bootstrap_processor::flush. --- nano/node/blockprocessor.cpp | 11 ----------- nano/node/blockprocessor.hpp | 1 - nano/node/bootstrap/bootstrap_legacy.cpp | 10 ++++++---- 3 files changed, 6 insertions(+), 16 deletions(-) diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index e696b5966b..76786fd247 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -37,17 +37,6 @@ void nano::block_processor::stop () nano::join_or_pass (processing_thread); } -void nano::block_processor::flush () -{ - flushing = true; - nano::unique_lock lock{ mutex }; - while (!stopped && (have_blocks () || active)) - { - condition.wait (lock); - } - flushing = false; -} - std::size_t nano::block_processor::size () { nano::unique_lock lock{ mutex }; diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index fc6c7172a0..a53fa80761 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -29,7 +29,6 @@ class block_processor final public: explicit block_processor (nano::node &, nano::write_database_queue &); void stop (); - void flush (); std::size_t size (); bool full (); bool half_full (); diff --git a/nano/node/bootstrap/bootstrap_legacy.cpp b/nano/node/bootstrap/bootstrap_legacy.cpp index 446d094646..9badee97cc 100644 --- a/nano/node/bootstrap/bootstrap_legacy.cpp +++ b/nano/node/bootstrap/bootstrap_legacy.cpp @@ -223,10 +223,12 @@ void nano::bootstrap_attempt_legacy::run () condition.wait (lock, [&stopped = stopped, &pulling = pulling] { return stopped || pulling == 0; }); } - // Flushing may resolve forks which can add more pulls - lock.unlock (); - node->block_processor.flush (); - lock.lock (); + // TODO: This check / wait is a heuristic and should be improved. + auto wait_start = std::chrono::steady_clock::now (); + while (!stopped && node->block_processor.size () != 0 && ((std::chrono::steady_clock::now () - wait_start) < std::chrono::seconds{ 10 })) + { + condition.wait_for (lock, std::chrono::milliseconds{ 100 }, [this, node] { return stopped || node->block_processor.size () == 0; }); + } if (start_account.number () != std::numeric_limits::max ()) { From 97e9b32ee56f9a7a35cd191494550f538f5a87f0 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Wed, 31 Jan 2024 22:47:16 +0700 Subject: [PATCH 051/190] Remove github cache saving and restoring from unit tests (#4399) --- .github/workflows/unit_tests.yml | 63 -------------------------------- 1 file changed, 63 deletions(-) diff --git a/.github/workflows/unit_tests.yml b/.github/workflows/unit_tests.yml index 83925c80c5..6a05626f9f 100644 --- a/.github/workflows/unit_tests.yml +++ b/.github/workflows/unit_tests.yml @@ -23,18 +23,6 @@ jobs: uses: actions/checkout@v3 with: submodules: "recursive" - fetch-depth: 0 # Full history needed for restoring file timestamps - - - name: Restore Timestamps - uses: ./.github/actions/restore-git-mtimes - continue-on-error: true - - - name: Restore Build Cache - uses: actions/cache/restore@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-build-cache - name: Prepare run: ci/prepare/macos/prepare.sh @@ -43,15 +31,6 @@ jobs: id: build run: ci/build-tests.sh - - name: Save Build Cache - # Only save build cache from develop to avoid polluting it by other branches / PRs - if: github.ref == 'refs/heads/develop' && success() - uses: actions/cache/save@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-build-cache - - name: Core Tests if: steps.build.outcome == 'success' && (success() || failure()) run: ../ci/tests/run-core-tests.sh @@ -90,18 +69,6 @@ jobs: uses: actions/checkout@v3 with: submodules: "recursive" - fetch-depth: 0 # Full history needed for restoring file timestamps - - - name: Restore Timestamps - uses: ./.github/actions/restore-git-mtimes - continue-on-error: true - - - name: Restore Build Cache - uses: actions/cache/restore@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-${{ env.COMPILER }}-build-cache - name: Prepare run: sudo -E ci/prepare/linux/prepare.sh @@ -110,15 +77,6 @@ jobs: id: build run: ci/build-tests.sh - - name: Save Build Cache - # Only save build cache from develop to avoid polluting it by other branches / PRs - if: github.ref == 'refs/heads/develop' && success() - uses: actions/cache/save@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-${{ env.COMPILER }}-build-cache - - name: Core Tests if: steps.build.outcome == 'success' && (success() || failure()) run: ../ci/tests/run-core-tests.sh @@ -160,18 +118,6 @@ jobs: uses: actions/checkout@v3 with: submodules: "recursive" - fetch-depth: 0 # full history needed for restoring file timestamps - - - name: Restore Timestamps - uses: ./.github/actions/restore-git-mtimes - continue-on-error: true - - - name: Restore Build Cache - uses: actions/cache/restore@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-build-cache - name: Prepare run: ci/prepare/windows/prepare.ps1 @@ -181,15 +127,6 @@ jobs: run: ci/build-tests.sh shell: bash - - name: Save Build Cache - # only save build cache from develop to avoid polluting it by other branches / PRs - if: github.ref == 'refs/heads/develop' && success() - uses: actions/cache/save@v3 - continue-on-error: true - with: - path: build - key: ${{ runner.os }}-build-cache - - name: Core Tests if: steps.build.outcome == 'success' && (success() || failure()) run: ../ci/tests/run-core-tests.sh From db409183640acc03423bd5c412404e65860224f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 31 Jan 2024 23:25:17 +0100 Subject: [PATCH 052/190] Update macOS runner (#4415) * Update macOS runner * Relax `timer.measure_and_compare` timings --- .github/workflows/artifacts_build_deploy.yml | 2 +- .github/workflows/unit_tests.yml | 2 +- nano/core_test/timer.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/artifacts_build_deploy.yml b/.github/workflows/artifacts_build_deploy.yml index 24de26309f..4f67d50e67 100644 --- a/.github/workflows/artifacts_build_deploy.yml +++ b/.github/workflows/artifacts_build_deploy.yml @@ -33,7 +33,7 @@ jobs: osx_job: needs: prepare_build if: ${{ needs.prepare_build.outputs.TAG_CREATED == 'true' }} - runs-on: macOS-12 + runs-on: macOS-14 timeout-minutes: 90 strategy: matrix: diff --git a/.github/workflows/unit_tests.yml b/.github/workflows/unit_tests.yml index 6a05626f9f..47fb08abf9 100644 --- a/.github/workflows/unit_tests.yml +++ b/.github/workflows/unit_tests.yml @@ -16,7 +16,7 @@ jobs: BUILD_TYPE: ${{ matrix.RELEASE && 'RelWithDebInfo' || 'Debug' }} TEST_USE_ROCKSDB: ${{ matrix.BACKEND == 'rocksdb' && '1' || '0' }} DEADLINE_SCALE_FACTOR: ${{ matrix.BACKEND == 'rocksdb' && '2' || '1' }} - runs-on: macos-12 + runs-on: macos-14 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - name: Checkout diff --git a/nano/core_test/timer.cpp b/nano/core_test/timer.cpp index cf718f11bd..85b3040739 100644 --- a/nano/core_test/timer.cpp +++ b/nano/core_test/timer.cpp @@ -39,7 +39,7 @@ TEST (timer, measure_and_compare) std::this_thread::sleep_for (50ms); ASSERT_TRUE (t1.after_deadline (30ms)); ASSERT_TRUE (t1.before_deadline (500ms)); - ASSERT_LT (t1.since_start (), 200ms); + ASSERT_LT (t1.since_start (), 500ms); ASSERT_GT (t1.since_start (), 10ms); ASSERT_GE (t1.stop (), 50ms); std::this_thread::sleep_for (50ms); From b1be78507ada0364588e1184006e65123347ecb3 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 1 Feb 2024 18:32:01 +0700 Subject: [PATCH 053/190] Remove unnecessary unlock/lock of a mutex (#4416) node.final_generator.add() used to do further work in the same context and there was the possibility of a deadlock. But now it just adds to a queue so there should not be a deadlock danger. So the lock/unlock should not be needed. --- nano/node/election.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 0ef35b349e..a8f03dae5a 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -366,10 +366,7 @@ void nano::election::confirm_if_quorum (nano::unique_lock & lock_a) { if (node.ledger.cache.final_votes_confirmation_canary.load () && !is_quorum.exchange (true) && node.config.enable_voting && node.wallets.reps ().voting > 0) { - auto hash = status.winner->hash (); - lock_a.unlock (); - node.final_generator.add (root, hash); - lock_a.lock (); + node.final_generator.add (root, status.winner->hash ()); } if (!node.ledger.cache.final_votes_confirmation_canary.load () || final_weight >= node.online_reps.delta ()) { From 38c0c347e4873ca022429d000c40fd91120ef768 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 1 Feb 2024 16:33:29 +0100 Subject: [PATCH 054/190] Update clang-format (#4414) * Update required `clang-format` version to 17 * Apply formatting --- .github/workflows/analyzers.yml | 37 +++++++++++++++++-------- ci/impl/clang-format.sh | 2 +- nano/lib/errors.cpp | 6 ++-- nano/lib/ipc_client.hpp | 2 +- nano/lib/jsonconfig.cpp | 2 +- nano/lib/locks.hpp | 6 ++-- nano/lib/memory.hpp | 4 +-- nano/lib/optional_ptr.hpp | 8 +++--- nano/lib/tomlconfig.cpp | 4 +-- nano/slow_test/bootstrap.cpp | 8 +++--- nano/store/iterator.hpp | 2 +- nano/store/lmdb/account.hpp | 24 ++++++++-------- nano/store/lmdb/block.hpp | 6 ++-- nano/store/lmdb/confirmation_height.hpp | 6 ++-- nano/store/lmdb/final_vote.hpp | 6 ++-- nano/store/lmdb/frontier.hpp | 6 ++-- nano/store/lmdb/iterator.hpp | 6 ++-- nano/store/lmdb/online_weight.hpp | 6 ++-- nano/store/lmdb/peer.hpp | 6 ++-- nano/store/lmdb/pending.hpp | 18 ++++++------ nano/store/lmdb/pruned.hpp | 6 ++-- nano/store/lmdb/version.hpp | 6 ++-- nano/store/rocksdb/iterator.hpp | 2 +- 23 files changed, 97 insertions(+), 82 deletions(-) diff --git a/.github/workflows/analyzers.yml b/.github/workflows/analyzers.yml index 8531a16032..52d9bb3829 100644 --- a/.github/workflows/analyzers.yml +++ b/.github/workflows/analyzers.yml @@ -1,36 +1,51 @@ name: Static Analyzers -on: [push, pull_request] +on: [ push, pull_request ] jobs: clang_format: - runs-on: ubuntu-20.04 + runs-on: ubuntu-22.04 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 #v3.1.0 - - name: Installing clang-format 12 + - name: Checkout + uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 #v3.1.0 + + - name: Installing clang-format env: DEBIAN_FRONTEND: noninteractive - run: sudo apt-get install clang-format-12 + run: | + wget https://apt.llvm.org/llvm.sh + chmod +x llvm.sh + sudo ./llvm.sh 17 + sudo apt install clang-format-17 + - name: Check clang-format run: ci/clang-format-check.sh - + + cmake_format: runs-on: ubuntu-20.04 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 #v3.1.0 - - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 #v4.3.0 - with: + - name: Checkout + uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 #v3.1.0 + + - name: Setup Python + uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 #v4.3.0 + with: python-version: '3.x' architecture: 'x64' - - uses: BSFishy/pip-action@8f2d471d809dc20b6ada98c91910b6ae6243f318 - with: + + - name: Install cmake-format + uses: BSFishy/pip-action@8f2d471d809dc20b6ada98c91910b6ae6243f318 + with: packages: | cmake-format + - name: Check cmake-format run: ci/cmake-format-check.sh + code_inspector: runs-on: ubuntu-20.04 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository diff --git a/ci/impl/clang-format.sh b/ci/impl/clang-format.sh index 3a3d69626e..bae7ad070f 100644 --- a/ci/impl/clang-format.sh +++ b/ci/impl/clang-format.sh @@ -3,7 +3,7 @@ ################################################################################################### CLANG_FORMAT="" -CLANG_FORMAT_VERSION="12" +CLANG_FORMAT_VERSION="17" ################################################################################################### diff --git a/nano/lib/errors.cpp b/nano/lib/errors.cpp index 822722be62..ffcb10a82b 100644 --- a/nano/lib/errors.cpp +++ b/nano/lib/errors.cpp @@ -373,9 +373,9 @@ nano::error::operator std::string () const } /** - * Get error message, or an empty string if there's no error. If a custom error message is set, - * that will be returned, otherwise the error_code#message() is returned. - */ + * Get error message, or an empty string if there's no error. If a custom error message is set, + * that will be returned, otherwise the error_code#message() is returned. + */ std::string nano::error::get_message () const { std::string res = message; diff --git a/nano/lib/ipc_client.hpp b/nano/lib/ipc_client.hpp index b3f5f93e1a..b0e2277fc3 100644 --- a/nano/lib/ipc_client.hpp +++ b/nano/lib/ipc_client.hpp @@ -84,7 +84,7 @@ namespace ipc } /** - * Returns a buffer with an IPC preamble for the given \p encoding_a followed by the payload. Depending on encoding, + * Returns a buffer with an IPC preamble for the given \p encoding_a followed by the payload. Depending on encoding, * the buffer may contain a payload length or end sentinel. */ nano::shared_const_buffer prepare_request (nano::ipc::payload_encoding encoding_a, std::string const & payload_a); diff --git a/nano/lib/jsonconfig.cpp b/nano/lib/jsonconfig.cpp index fb5a857d25..74523154c2 100644 --- a/nano/lib/jsonconfig.cpp +++ b/nano/lib/jsonconfig.cpp @@ -21,7 +21,7 @@ nano::jsonconfig::jsonconfig (boost::property_tree::ptree & tree_a, std::shared_ } /** - * Reads a json object from the stream + * Reads a json object from the stream * @return nano::error&, including a descriptive error message if the config file is malformed. */ nano::error & nano::jsonconfig::read (std::filesystem::path const & path_a) diff --git a/nano/lib/locks.hpp b/nano/lib/locks.hpp index cb490e455c..f8447edff4 100644 --- a/nano/lib/locks.hpp +++ b/nano/lib/locks.hpp @@ -179,7 +179,7 @@ class unique_lock final }; /** Assumes std implementations of std::condition_variable never actually call nano::unique_lock::lock/unlock, - but instead use OS intrinsics with the mutex handle directly. Due to this we also do not account for any + but instead use OS intrinsics with the mutex handle directly. Due to this we also do not account for any time the condition variable is blocked on another holder of the mutex. */ class condition_variable final { @@ -283,7 +283,7 @@ class locked owner->mutex.unlock (); } - T * operator-> () + T * operator->() { return &owner->obj; } @@ -301,7 +301,7 @@ class locked locked * owner{ nullptr }; }; - scoped_lock operator-> () + scoped_lock operator->() { return scoped_lock (this); } diff --git a/nano/lib/memory.hpp b/nano/lib/memory.hpp index 6a484540d3..333a5ff980 100644 --- a/nano/lib/memory.hpp +++ b/nano/lib/memory.hpp @@ -16,8 +16,8 @@ bool get_use_memory_pools (); void set_use_memory_pools (bool use_memory_pools); /** This makes some heuristic assumptions about the implementation defined shared_ptr internals. - Should only be used in the memory pool purge functions at exit, which doesn't matter much if - it is incorrect (other than reports from heap memory analysers) */ + Should only be used in the memory pool purge functions at exit, which doesn't matter much if + it is incorrect (other than reports from heap memory analysers) */ template constexpr size_t determine_shared_ptr_pool_size () { diff --git a/nano/lib/optional_ptr.hpp b/nano/lib/optional_ptr.hpp index 56695fc3ed..8c5fdc2fe7 100644 --- a/nano/lib/optional_ptr.hpp +++ b/nano/lib/optional_ptr.hpp @@ -55,14 +55,14 @@ class optional_ptr return *ptr; } - T * const operator-> () + T * const operator->() { - return ptr.operator-> (); + return ptr.operator->(); } - T const * const operator-> () const + T const * const operator->() const { - return ptr.operator-> (); + return ptr.operator->(); } T const * const get () const diff --git a/nano/lib/tomlconfig.cpp b/nano/lib/tomlconfig.cpp index bf1bd13eff..ee8d9e6f28 100644 --- a/nano/lib/tomlconfig.cpp +++ b/nano/lib/tomlconfig.cpp @@ -166,8 +166,8 @@ std::shared_ptr nano::tomlconfig::create_array (std::string cons } /** - * Erase keys whose values are equal to the one in \p defaults - */ + * Erase keys whose values are equal to the one in \p defaults + */ void nano::tomlconfig::erase_default_values (tomlconfig & defaults_a) { std::shared_ptr clone = std::dynamic_pointer_cast (tree->clone ()); diff --git a/nano/slow_test/bootstrap.cpp b/nano/slow_test/bootstrap.cpp index b500e4a009..070da58f5a 100644 --- a/nano/slow_test/bootstrap.cpp +++ b/nano/slow_test/bootstrap.cpp @@ -77,7 +77,7 @@ TEST (bootstrap_ascending, profile) flags_server.disable_ongoing_bootstrap = true; flags_server.disable_ascending_bootstrap = true; auto data_path_server = nano::working_path (network); - //auto data_path_server = ""; + // auto data_path_server = ""; auto server = std::make_shared (system.io_ctx, data_path_server, config_server, system.work, flags_server); system.nodes.push_back (server); server->start (); @@ -93,10 +93,10 @@ TEST (bootstrap_ascending, profile) config_client.ipc_config.transport_tcp.enabled = true; // Disable database integrity safety for higher throughput config_client.lmdb_config.sync = nano::lmdb_config::sync_strategy::nosync_unsafe; - //auto client = system.add_node (config_client, flags_client); + // auto client = system.add_node (config_client, flags_client); // macos 16GB RAM disk: diskutil erasevolume HFS+ "RAMDisk" `hdiutil attach -nomount ram://33554432` - //auto data_path_client = "/Volumes/RAMDisk"; + // auto data_path_client = "/Volumes/RAMDisk"; auto data_path_client = nano::unique_path (); auto client = std::make_shared (system.io_ctx, data_path_client, config_client, system.work, flags_client); system.nodes.push_back (client); @@ -186,7 +186,7 @@ TEST (bootstrap_ascending, profile) rate.observe (*client, nano::stat::type::ledger, nano::stat::detail::gap_previous, nano::stat::dir::in); rate.background_print (3s); - //wait_for_key (); + // wait_for_key (); while (true) { nano::test::establish_tcp (system, *client, server->network.endpoint ()); diff --git a/nano/store/iterator.hpp b/nano/store/iterator.hpp index 00f2ab7f93..aef5cc709f 100644 --- a/nano/store/iterator.hpp +++ b/nano/store/iterator.hpp @@ -45,7 +45,7 @@ class iterator final return *this; } iterator & operator= (iterator const &) = delete; - std::pair * operator-> () + std::pair * operator->() { return ¤t; } diff --git a/nano/store/lmdb/account.hpp b/nano/store/lmdb/account.hpp index 9c3284b482..6faaf3cfe8 100644 --- a/nano/store/lmdb/account.hpp +++ b/nano/store/lmdb/account.hpp @@ -29,27 +29,27 @@ class account : public nano::store::account void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed) - * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t - */ + * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed) + * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t + */ MDB_dbi accounts_v0_handle{ 0 }; /** - * Maps account v0 to account information, head, rep, open, balance, timestamp and block count. (Removed) - * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t - */ + * Maps account v0 to account information, head, rep, open, balance, timestamp and block count. (Removed) + * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t + */ MDB_dbi accounts_v1_handle{ 0 }; /** - * Maps account v0 to account information, head, rep, open, balance, timestamp, block count and epoch - * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t, nano::epoch - */ + * Maps account v0 to account information, head, rep, open, balance, timestamp, block count and epoch + * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t, nano::epoch + */ MDB_dbi accounts_handle{ 0 }; /** - * Representative weights. (Removed) - * nano::account -> nano::uint128_t - */ + * Representative weights. (Removed) + * nano::account -> nano::uint128_t + */ MDB_dbi representation_handle{ 0 }; }; } // amespace nano::store::lmdb diff --git a/nano/store/lmdb/block.hpp b/nano/store/lmdb/block.hpp index a16f213859..b9ccc3b475 100644 --- a/nano/store/lmdb/block.hpp +++ b/nano/store/lmdb/block.hpp @@ -37,9 +37,9 @@ class block : public nano::store::block void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks) - * nano::block_hash -> nano::block_sideband, nano::block - */ + * Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks) + * nano::block_hash -> nano::block_sideband, nano::block + */ MDB_dbi blocks_handle{ 0 }; protected: diff --git a/nano/store/lmdb/confirmation_height.hpp b/nano/store/lmdb/confirmation_height.hpp index 738c8482c6..4674f81137 100644 --- a/nano/store/lmdb/confirmation_height.hpp +++ b/nano/store/lmdb/confirmation_height.hpp @@ -29,9 +29,9 @@ class confirmation_height : public nano::store::confirmation_height void for_each_par (std::function, store::iterator)> const & action_a) const override; /* - * Confirmation height of an account, and the hash for the block at that height - * nano::account -> uint64_t, nano::block_hash - */ + * Confirmation height of an account, and the hash for the block at that height + * nano::account -> uint64_t, nano::block_hash + */ MDB_dbi confirmation_height_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/final_vote.hpp b/nano/store/lmdb/final_vote.hpp index b7c06c62fd..92fc5253fd 100644 --- a/nano/store/lmdb/final_vote.hpp +++ b/nano/store/lmdb/final_vote.hpp @@ -29,9 +29,9 @@ class final_vote : public nano::store::final_vote void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Maps root to block hash for generated final votes. - * nano::qualified_root -> nano::block_hash - */ + * Maps root to block hash for generated final votes. + * nano::qualified_root -> nano::block_hash + */ MDB_dbi final_votes_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/frontier.hpp b/nano/store/lmdb/frontier.hpp index 6bf71068bf..95205d4cd0 100644 --- a/nano/store/lmdb/frontier.hpp +++ b/nano/store/lmdb/frontier.hpp @@ -26,9 +26,9 @@ class frontier : public nano::store::frontier void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Maps head block to owning account - * nano::block_hash -> nano::account - */ + * Maps head block to owning account + * nano::block_hash -> nano::account + */ MDB_dbi frontiers_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/iterator.hpp b/nano/store/lmdb/iterator.hpp index e8230fd73f..ff7cb0977c 100644 --- a/nano/store/lmdb/iterator.hpp +++ b/nano/store/lmdb/iterator.hpp @@ -95,7 +95,7 @@ class iterator : public iterator_impl return *this; } - std::pair, store::db_val> * operator-> () + std::pair, store::db_val> * operator->() { return ¤t; } @@ -213,9 +213,9 @@ class merge_iterator : public iterator_impl return *this; } - std::pair, store::db_val> * operator-> () + std::pair, store::db_val> * operator->() { - return least_iterator ().operator-> (); + return least_iterator ().operator->(); } bool operator== (merge_iterator const & other) const diff --git a/nano/store/lmdb/online_weight.hpp b/nano/store/lmdb/online_weight.hpp index df70dfb9d0..0567c63d9b 100644 --- a/nano/store/lmdb/online_weight.hpp +++ b/nano/store/lmdb/online_weight.hpp @@ -22,9 +22,9 @@ class online_weight : public nano::store::online_weight void clear (store::write_transaction const & transaction_a) override; /** - * Samples of online vote weight - * uint64_t -> nano::amount - */ + * Samples of online vote weight + * uint64_t -> nano::amount + */ MDB_dbi online_weight_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/peer.hpp b/nano/store/lmdb/peer.hpp index 7519908eee..13ae1b59f3 100644 --- a/nano/store/lmdb/peer.hpp +++ b/nano/store/lmdb/peer.hpp @@ -22,9 +22,9 @@ class peer : public nano::store::peer store::iterator end () const override; /* - * Endpoints for peers - * nano::endpoint_key -> no_value - */ + * Endpoints for peers + * nano::endpoint_key -> no_value + */ MDB_dbi peers_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/pending.hpp b/nano/store/lmdb/pending.hpp index 7b39a9132c..1c110fa186 100644 --- a/nano/store/lmdb/pending.hpp +++ b/nano/store/lmdb/pending.hpp @@ -28,21 +28,21 @@ class pending : public nano::store::pending void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed) - * nano::account, nano::block_hash -> nano::account, nano::amount - */ + * Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed) + * nano::account, nano::block_hash -> nano::account, nano::amount + */ MDB_dbi pending_v0_handle{ 0 }; /** - * Maps min_version 1 (destination account, pending block) to (source account, amount). (Removed) - * nano::account, nano::block_hash -> nano::account, nano::amount - */ + * Maps min_version 1 (destination account, pending block) to (source account, amount). (Removed) + * nano::account, nano::block_hash -> nano::account, nano::amount + */ MDB_dbi pending_v1_handle{ 0 }; /** - * Maps (destination account, pending block) to (source account, amount, version). (Removed) - * nano::account, nano::block_hash -> nano::account, nano::amount, nano::epoch - */ + * Maps (destination account, pending block) to (source account, amount, version). (Removed) + * nano::account, nano::block_hash -> nano::account, nano::amount, nano::epoch + */ MDB_dbi pending_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/pruned.hpp b/nano/store/lmdb/pruned.hpp index d0c3c5d075..0aa2d7fc20 100644 --- a/nano/store/lmdb/pruned.hpp +++ b/nano/store/lmdb/pruned.hpp @@ -25,9 +25,9 @@ class pruned : public nano::store::pruned void for_each_par (std::function, store::iterator)> const & action_a) const override; /** - * Pruned blocks hashes - * nano::block_hash -> none - */ + * Pruned blocks hashes + * nano::block_hash -> none + */ MDB_dbi pruned_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/lmdb/version.hpp b/nano/store/lmdb/version.hpp index fa9cb04298..7ec10b8183 100644 --- a/nano/store/lmdb/version.hpp +++ b/nano/store/lmdb/version.hpp @@ -17,9 +17,9 @@ class version : public nano::store::version int get (store::transaction const & transaction_a) const override; /** - * Meta information about block store, such as versions. - * nano::uint256_union (arbitrary key) -> blob - */ + * Meta information about block store, such as versions. + * nano::uint256_union (arbitrary key) -> blob + */ MDB_dbi meta_handle{ 0 }; }; } // namespace nano::store::lmdb diff --git a/nano/store/rocksdb/iterator.hpp b/nano/store/rocksdb/iterator.hpp index 0351367828..ec4865e526 100644 --- a/nano/store/rocksdb/iterator.hpp +++ b/nano/store/rocksdb/iterator.hpp @@ -129,7 +129,7 @@ class iterator : public iterator_impl return *this; } - std::pair * operator-> () + std::pair * operator->() { return ¤t; } From 83e0997497b6411b5062345bc90aad8ec543db2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 1 Feb 2024 16:34:03 +0100 Subject: [PATCH 055/190] Separate `node.expire` test (#4417) --- nano/core_test/node.cpp | 77 ++++++++++++++++++++++------------------- 1 file changed, 42 insertions(+), 35 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 68084f9236..996961054f 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -546,7 +546,7 @@ TEST (node_config, random_rep) ASSERT_NE (config1.preconfigured_representatives.end (), std::find (config1.preconfigured_representatives.begin (), config1.preconfigured_representatives.end (), rep)); } -TEST (node, fork_publish) +TEST (node, expire) { std::weak_ptr node0; { @@ -554,44 +554,51 @@ TEST (node, fork_publish) node0 = system.nodes[0]; auto & node1 (*system.nodes[0]); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - nano::keypair key1; - nano::send_block_builder builder; - auto send1 = builder.make_block () - .previous (nano::dev::genesis->hash ()) - .destination (key1.pub) - .balance (nano::dev::constants.genesis_amount - 100) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (0) - .build_shared (); - node1.work_generate_blocking (*send1); - nano::keypair key2; - auto send2 = builder.make_block () - .previous (nano::dev::genesis->hash ()) - .destination (key2.pub) - .balance (nano::dev::constants.genesis_amount - 100) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (0) - .build_shared (); - node1.work_generate_blocking (*send2); - node1.process_active (send1); - ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); - auto election (node1.active.election (send1->qualified_root ())); - ASSERT_NE (nullptr, election); - // Wait until the genesis rep activated & makes vote - ASSERT_TIMELY_EQ (1s, election->votes ().size (), 2); - node1.process_active (send2); - ASSERT_TIMELY (5s, node1.active.active (*send2)); - auto votes1 (election->votes ()); - auto existing1 (votes1.find (nano::dev::genesis_key.pub)); - ASSERT_NE (votes1.end (), existing1); - ASSERT_EQ (send1->hash (), existing1->second.hash); - auto winner (*election->tally ().begin ()); - ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); } ASSERT_TRUE (node0.expired ()); } +TEST (node, fork_publish) +{ + nano::test::system system (1); + auto & node1 (*system.nodes[0]); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::keypair key1; + nano::send_block_builder builder; + auto send1 = builder.make_block () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); + node1.work_generate_blocking (*send1); + nano::keypair key2; + auto send2 = builder.make_block () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); + node1.work_generate_blocking (*send2); + node1.process_active (send1); + ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); + auto election (node1.active.election (send1->qualified_root ())); + ASSERT_NE (nullptr, election); + // Wait until the genesis rep activated & makes vote + ASSERT_TIMELY_EQ (1s, election->votes ().size (), 2); + node1.process_active (send2); + ASSERT_TIMELY (5s, node1.active.active (*send2)); + auto votes1 (election->votes ()); + auto existing1 (votes1.find (nano::dev::genesis_key.pub)); + ASSERT_NE (votes1.end (), existing1); + ASSERT_EQ (send1->hash (), existing1->second.hash); + auto winner (*election->tally ().begin ()); + ASSERT_EQ (*send1, *winner.second); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); +} + // In test case there used to be a race condition, it was worked around in:. // https://github.com/nanocurrency/nano-node/pull/4091 // The election and the processing of block send2 happen in parallel. From 647c3c4a2d750f6e03d0c3af6f768fde9c64cb64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 1 Feb 2024 16:34:45 +0100 Subject: [PATCH 056/190] Allow overriding of default application path directory (#4418) --- nano/secure/utility.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp index 0ed99eb9b1..d7e263d81f 100644 --- a/nano/secure/utility.cpp +++ b/nano/secure/utility.cpp @@ -9,6 +9,13 @@ static std::vector all_unique_paths; std::filesystem::path nano::working_path (nano::networks network) { auto result (nano::app_path ()); + + if (auto path_override = nano::get_env ("NANO_APP_PATH")) + { + result = *path_override; + std::cerr << "Application path overridden by NANO_APP_PATH environment variable: " << result << std::endl; + } + switch (network) { case nano::networks::invalid: From 401719e3066d9e99e449af2613a20b3c56061b1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 23 Jan 2024 00:39:41 +0100 Subject: [PATCH 057/190] Unique object id generation --- nano/lib/id_dispenser.hpp | 13 +++++++++++++ nano/node/election.hpp | 2 ++ nano/store/lmdb/lmdb_env.hpp | 7 +------ 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/nano/lib/id_dispenser.hpp b/nano/lib/id_dispenser.hpp index 4b0cc53fe5..91aa651a17 100644 --- a/nano/lib/id_dispenser.hpp +++ b/nano/lib/id_dispenser.hpp @@ -59,4 +59,17 @@ class id_dispenser return dist; } }; + +inline id_dispenser & id_gen () +{ + static id_dispenser id_gen; + return id_gen; +} + +using id_t = id_dispenser::id_t; + +inline id_t next_id () +{ + return id_gen ().next_id (); +} } \ No newline at end of file diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 8c025f654a..ffc0d9981b 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -75,6 +75,8 @@ struct election_extended_status final class election final : public std::enable_shared_from_this { + nano::id_t const id{ nano::next_id () }; // Track individual objects when tracing + public: enum class vote_source { diff --git a/nano/store/lmdb/lmdb_env.hpp b/nano/store/lmdb/lmdb_env.hpp index f947077c6b..e912653250 100644 --- a/nano/store/lmdb/lmdb_env.hpp +++ b/nano/store/lmdb/lmdb_env.hpp @@ -5,11 +5,6 @@ #include #include -namespace -{ -nano::id_dispenser id_gen; -} - namespace nano::store::lmdb { /** @@ -68,6 +63,6 @@ class env final store::write_transaction tx_begin_write (txn_callbacks callbacks = txn_callbacks{}) const; MDB_txn * tx (store::transaction const & transaction_a) const; MDB_env * environment; - nano::id_dispenser::id_t const store_id{ id_gen.next_id () }; + nano::id_t const store_id{ nano::next_id () }; }; } // namespace nano::store::lmdb From 1dd8ab4746d0bc2603cdac94cea496adfc03c011 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 23 Jan 2024 12:42:29 +0100 Subject: [PATCH 058/190] Logger id lookup improvements --- nano/lib/logging.cpp | 109 ++++++++++++++++++++++++++----------------- nano/lib/logging.hpp | 48 ++++++++++--------- 2 files changed, 94 insertions(+), 63 deletions(-) diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 3630c23d02..2860d76eb8 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -3,6 +3,7 @@ #include #include +#include #include #include #include @@ -24,8 +25,8 @@ nano::log_config nano::logger::global_config{}; std::vector nano::logger::global_sinks{}; // By default, use only the tag as the logger name, since only one node is running in the process -std::function nano::logger::global_name_formatter{ [] (auto tag, auto identifier) { - return std::string{ to_string (tag) }; +std::function nano::logger::global_name_formatter{ [] (nano::log::logger_id logger_id, std::string identifier) { + return to_string (logger_id); } }; void nano::logger::initialize (nano::log_config fallback, std::optional data_path, std::vector const & config_overrides) @@ -96,8 +97,8 @@ void nano::logger::initialize_for_tests (nano::log_config fallback) initialize_common (config, /* store log file in current workdir */ std::filesystem::current_path ()); // Use tag and identifier as the logger name, since multiple nodes may be running in the same process - global_name_formatter = [] (nano::log::type tag, std::string identifier) { - return fmt::format ("{}::{}", identifier, to_string (tag)); + global_name_formatter = [] (nano::log::logger_id logger_id, std::string identifier) { + return fmt::format ("{}::{}", identifier, to_string (logger_id)); }; // Setup formatter to include information about node identifier `[%i]` and tag `[%n]` @@ -209,13 +210,13 @@ nano::logger::~logger () flush (); } -spdlog::logger & nano::logger::get_logger (nano::log::type tag) +spdlog::logger & nano::logger::get_logger (nano::log::type type, nano::log::detail detail) { // This is a two-step process to avoid exclusively locking the mutex in the common case { std::shared_lock lock{ mutex }; - if (auto it = spd_loggers.find (tag); it != spd_loggers.end ()) + if (auto it = spd_loggers.find ({ type, detail }); it != spd_loggers.end ()) { return *it->second; } @@ -224,31 +225,42 @@ spdlog::logger & nano::logger::get_logger (nano::log::type tag) { std::unique_lock lock{ mutex }; - auto [it, inserted] = spd_loggers.emplace (tag, make_logger (tag)); + auto [it, inserted] = spd_loggers.emplace (std::make_pair (type, detail), make_logger ({ type, detail })); return *it->second; } } -std::shared_ptr nano::logger::make_logger (nano::log::type tag) +std::shared_ptr nano::logger::make_logger (nano::log::logger_id logger_id) { auto const & config = global_config; auto const & sinks = global_sinks; - auto name = global_name_formatter (tag, identifier); + auto name = global_name_formatter (logger_id, identifier); auto spd_logger = std::make_shared (name, sinks.begin (), sinks.end ()); - if (auto it = config.levels.find ({ tag, nano::log::detail::all }); it != config.levels.end ()) + spd_logger->set_level (to_spdlog_level (find_level (logger_id))); + spd_logger->flush_on (to_spdlog_level (config.flush_level)); + + return spd_logger; +} + +nano::log::level nano::logger::find_level (nano::log::logger_id logger_id) const +{ + auto const & config = global_config; + auto const & [type, detail] = logger_id; + + // Check for a specific level for this logger + if (auto it = config.levels.find (logger_id); it != config.levels.end ()) { - spd_logger->set_level (to_spdlog_level (it->second)); + return it->second; } - else + // Check for a default level for this logger type + if (auto it = config.levels.find ({ type, nano::log::detail::all }); it != config.levels.end ()) { - spd_logger->set_level (to_spdlog_level (config.default_level)); + return it->second; } - - spd_logger->flush_on (to_spdlog_level (config.flush_level)); - - return spd_logger; + // Use the default level + return config.default_level; } spdlog::level::level_enum nano::logger::to_spdlog_level (nano::log::level level) @@ -400,7 +412,7 @@ void nano::log_config::deserialize (nano::tomlconfig & toml) { auto & [name_str, level_str] = level; auto logger_level = nano::log::parse_level (level_str); - auto logger_id = parse_logger_id (name_str); + auto logger_id = nano::log::parse_logger_id (name_str); levels[logger_id] = logger_level; } @@ -413,29 +425,9 @@ void nano::log_config::deserialize (nano::tomlconfig & toml) } } -/** - * Parse `logger_name[:logger_detail]` into a pair of `log::type` and `log::detail` - * @throw std::invalid_argument if `logger_name` or `logger_detail` are invalid - */ -nano::log_config::logger_id_t nano::log_config::parse_logger_id (const std::string & logger_name) +std::map nano::log_config::default_levels (nano::log::level default_level) { - auto pos = logger_name.find ("::"); - if (pos == std::string::npos) - { - return { nano::log::parse_type (logger_name), nano::log::detail::all }; - } - else - { - auto logger_type = logger_name.substr (0, pos); - auto logger_detail = logger_name.substr (pos + 1); - - return { nano::log::parse_type (logger_type), nano::log::parse_detail (logger_detail) }; - } -} - -std::map nano::log_config::default_levels (nano::log::level default_level) -{ - std::map result; + std::map result; for (auto const & type : nano::log::all_types ()) { result.emplace (std::make_pair (type, nano::log::detail::all), default_level); @@ -475,7 +467,7 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi auto env_levels = nano::get_env ("NANO_LOG_LEVELS"); if (env_levels) { - std::map levels; + std::map levels; for (auto const & env_level_str : nano::util::split (*env_levels, ',')) { try @@ -490,7 +482,7 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi auto name_str = arr[0]; auto level_str = arr[1]; - auto logger_id = nano::log_config::parse_logger_id (name_str); + auto logger_id = nano::log::parse_logger_id (name_str); auto logger_level = nano::log::parse_level (level_str); levels[logger_id] = logger_level; @@ -517,4 +509,37 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi std::cerr << "Unable to load log config. Using defaults. Error: " << ex.what () << std::endl; } return fallback; +} + +std::string nano::log::to_string (nano::log::logger_id logger_id) +{ + auto const & [type, detail] = logger_id; + if (detail == nano::log::detail::all) + { + return fmt::format ("{}", to_string (type)); + } + else + { + return fmt::format ("{}::{}", to_string (type), to_string (detail)); + } +} + +/** + * Parse `logger_name[:logger_detail]` into a pair of `log::type` and `log::detail` + * @throw std::invalid_argument if `logger_name` or `logger_detail` are invalid + */ +nano::log::logger_id nano::log::parse_logger_id (const std::string & logger_name) +{ + auto pos = logger_name.find ("::"); + if (pos == std::string::npos) + { + return { nano::log::parse_type (logger_name), nano::log::detail::all }; + } + else + { + auto logger_type = logger_name.substr (0, pos); + auto logger_detail = logger_name.substr (pos + 1); + + return { nano::log::parse_type (logger_type), nano::log::parse_detail (logger_detail) }; + } } \ No newline at end of file diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 55f08ad64f..00b1cddbab 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -10,6 +10,14 @@ #include +namespace nano::log +{ +using logger_id = std::pair; + +std::string to_string (logger_id); +logger_id parse_logger_id (std::string const &); +} + namespace nano { class log_config final @@ -26,8 +34,7 @@ class log_config final nano::log::level default_level{ nano::log::level::info }; nano::log::level flush_level{ nano::log::level::error }; - using logger_id_t = std::pair; - std::map levels; + std::map levels; struct console_config { @@ -52,11 +59,9 @@ class log_config final static log_config tests_default (); static log_config sample_config (); // For auto-generated sample config files - static logger_id_t parse_logger_id (std::string const &); - private: /// Returns placeholder log levels for all loggers - static std::map default_levels (nano::log::level); + static std::map default_levels (nano::log::level); }; nano::log_config load_log_config (nano::log_config fallback, std::filesystem::path const & data_path, std::vector const & config_overrides = {}); @@ -79,56 +84,57 @@ class logger final static bool global_initialized; static nano::log_config global_config; static std::vector global_sinks; - static std::function global_name_formatter; + static std::function global_name_formatter; static void initialize_common (nano::log_config const &, std::optional data_path); public: template - void log (nano::log::level level, nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void log (nano::log::level level, nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).log (to_spdlog_level (level), fmt, std::forward (args)...); + get_logger (type).log (to_spdlog_level (level), fmt, std::forward (args)...); } template - void debug (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void debug (nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).debug (fmt, std::forward (args)...); + get_logger (type).debug (fmt, std::forward (args)...); } template - void info (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void info (nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).info (fmt, std::forward (args)...); + get_logger (type).info (fmt, std::forward (args)...); } template - void warn (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void warn (nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).warn (fmt, std::forward (args)...); + get_logger (type).warn (fmt, std::forward (args)...); } template - void error (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void error (nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).error (fmt, std::forward (args)...); + get_logger (type).error (fmt, std::forward (args)...); } template - void critical (nano::log::type tag, spdlog::format_string_t fmt, Args &&... args) + void critical (nano::log::type type, spdlog::format_string_t fmt, Args &&... args) { - get_logger (tag).critical (fmt, std::forward (args)...); + get_logger (type).critical (fmt, std::forward (args)...); } private: const std::string identifier; - std::unordered_map> spd_loggers; + std::map> spd_loggers; std::shared_mutex mutex; private: - spdlog::logger & get_logger (nano::log::type tag); - std::shared_ptr make_logger (nano::log::type tag); + spdlog::logger & get_logger (nano::log::type, nano::log::detail = nano::log::detail::all); + std::shared_ptr make_logger (nano::log::logger_id); + nano::log::level find_level (nano::log::logger_id) const; static spdlog::level::level_enum to_spdlog_level (nano::log::level); }; From 7ac49e8ffdec7681c442ec898209543de1920926 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 23 Jan 2024 00:30:39 +0100 Subject: [PATCH 059/190] Election locks fix --- nano/node/election.cpp | 16 ++++++++-------- nano/node/election.hpp | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/nano/node/election.cpp b/nano/node/election.cpp index a8f03dae5a..228da61a94 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -165,16 +165,16 @@ void nano::election::transition_active () state_change (nano::election::state_t::passive, nano::election::state_t::active); } -bool nano::election::confirmed_locked (nano::unique_lock & lock) const +bool nano::election::confirmed_locked () const { - debug_assert (lock.owns_lock ()); + debug_assert (!mutex.try_lock ()); return state_m == nano::election::state_t::confirmed || state_m == nano::election::state_t::expired_confirmed; } bool nano::election::confirmed () const { nano::unique_lock lock{ mutex }; - return confirmed_locked (lock); + return confirmed_locked (); } bool nano::election::failed () const @@ -245,7 +245,7 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a break; } - if (!confirmed_locked (lock) && time_to_live () < std::chrono::steady_clock::now () - election_start) + if (!confirmed_locked () && time_to_live () < std::chrono::steady_clock::now () - election_start) { // It is possible the election confirmed while acquiring the mutex // state_change returning true would indicate it @@ -383,7 +383,7 @@ boost::optional nano::election::try_confirm (nano::b if (winner && winner->hash () == hash) { // Determine if the block was confirmed explicitly via election confirmation or implicitly via confirmation height - if (!confirmed_locked (election_lock)) + if (!confirmed_locked ()) { confirm_once (election_lock, nano::election_status_type::active_confirmation_height); status_type = nano::election_status_type::active_confirmation_height; @@ -466,7 +466,7 @@ nano::election_vote_result nano::election::vote (nano::account const & rep, uint node.stats.inc (nano::stat::type::election, vote_source_a == vote_source::live ? nano::stat::detail::vote_new : nano::stat::detail::vote_cached); - if (!confirmed_locked (lock)) + if (!confirmed_locked ()) { confirm_if_quorum (lock); } @@ -478,7 +478,7 @@ bool nano::election::publish (std::shared_ptr const & block_a) nano::unique_lock lock{ mutex }; // Do not insert new blocks if already confirmed - auto result (confirmed_locked (lock)); + auto result (confirmed_locked ()); if (!result && last_blocks.size () >= max_blocks && last_blocks.find (block_a->hash ()) == last_blocks.end ()) { if (!replace_by_weight (lock, block_a->hash ())) @@ -544,7 +544,7 @@ void nano::election::broadcast_vote_locked (nano::unique_lock & loc { node.stats.inc (nano::stat::type::election, nano::stat::detail::generate_vote); - if (confirmed_locked (lock) || have_quorum (tally_impl ())) + if (confirmed_locked () || have_quorum (tally_impl ())) { node.stats.inc (nano::stat::type::election, nano::stat::detail::generate_vote_final); node.final_generator.add (root, status.winner->hash ()); // Broadcasts vote to the network diff --git a/nano/node/election.hpp b/nano/node/election.hpp index ffc0d9981b..b9561fc68a 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -168,7 +168,7 @@ class election final : public std::enable_shared_from_this private: nano::tally_t tally_impl () const; - bool confirmed_locked (nano::unique_lock & lock) const; + bool confirmed_locked () const; // lock_a does not own the mutex on return void confirm_once (nano::unique_lock & lock_a, nano::election_status_type = nano::election_status_type::active_confirmed_quorum); void broadcast_block (nano::confirmation_solicitor &); From 0f7b60df45012a585487aa9fe860d761e96a2496 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 28 Jan 2024 21:32:18 +0100 Subject: [PATCH 060/190] Improve `nano::util::join` --- nano/lib/utility.hpp | 2 +- nano/secure/vote.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 61beefeeb4..97d8bd3ad5 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -232,7 +232,7 @@ std::string join (InputIt first, InputIt last, std::string_view delimiter, Func } else { - ss << delimiter << " "; + ss << delimiter; } ss << transform (*first); ++first; diff --git a/nano/secure/vote.cpp b/nano/secure/vote.cpp index 208aca4de1..9ffeabe04a 100644 --- a/nano/secure/vote.cpp +++ b/nano/secure/vote.cpp @@ -165,7 +165,7 @@ std::string nano::vote::to_json () const std::string nano::vote::hashes_string () const { - return nano::util::join (hashes, ",", [] (auto const & hash) { + return nano::util::join (hashes, ", ", [] (auto const & hash) { return hash.to_string (); }); } From 18749c26ce96fd0dd91eda2af812934fe2203742 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 22 Jan 2024 20:51:21 +0100 Subject: [PATCH 061/190] Tracing --- CMakeLists.txt | 6 + ci/build.sh | 1 + nano/core_test/CMakeLists.txt | 3 +- nano/core_test/election.cpp | 4 +- nano/core_test/logger.cpp | 16 - nano/core_test/logging.cpp | 106 ++++ nano/core_test/object_stream.cpp | 559 ++++++++++++++++++++ nano/lib/CMakeLists.txt | 3 + nano/lib/blocks.cpp | 123 ++++- nano/lib/blocks.hpp | 37 ++ nano/lib/logging.cpp | 57 +- nano/lib/logging.hpp | 52 +- nano/lib/logging_enums.cpp | 35 ++ nano/lib/logging_enums.hpp | 47 +- nano/lib/object_stream.cpp | 28 + nano/lib/object_stream.hpp | 555 +++++++++++++++++++ nano/lib/object_stream_adapters.hpp | 127 +++++ nano/lib/stats_enums.hpp | 8 + nano/node/active_transactions.cpp | 16 +- nano/node/blockprocessor.cpp | 4 + nano/node/bootstrap/bootstrap_bulk_pull.cpp | 20 + nano/node/bootstrap/bootstrap_frontier.cpp | 5 + nano/node/election.cpp | 93 +++- nano/node/election.hpp | 8 + nano/node/messages.cpp | 334 ++++++------ nano/node/messages.hpp | 108 +++- nano/node/network.cpp | 3 +- nano/node/node.cpp | 6 +- nano/node/scheduler/priority.cpp | 17 +- nano/node/transport/channel.cpp | 15 + nano/node/transport/channel.hpp | 4 + nano/node/transport/socket.cpp | 25 +- nano/node/transport/socket.hpp | 5 +- nano/node/transport/tcp.cpp | 7 + nano/node/transport/tcp.hpp | 4 + nano/node/vote_processor.cpp | 4 + nano/node/voting.cpp | 12 +- nano/node/voting.hpp | 4 +- nano/secure/common.hpp | 1 + nano/secure/vote.cpp | 8 + nano/secure/vote.hpp | 3 + 41 files changed, 2216 insertions(+), 257 deletions(-) delete mode 100644 nano/core_test/logger.cpp create mode 100644 nano/core_test/logging.cpp create mode 100644 nano/core_test/object_stream.cpp create mode 100644 nano/lib/object_stream.cpp create mode 100644 nano/lib/object_stream.hpp create mode 100644 nano/lib/object_stream_adapters.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a4c1ba48de..408ed1880a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -133,6 +133,12 @@ if(NANO_STACKTRACE_BACKTRACE) endif() endif() +option(NANO_TRACING "Enable trace logging" OFF) +if(NANO_TRACING) + message(STATUS "Using trace logging") + add_compile_definitions(NANO_TRACING) +endif() + if(${NANO_TIMED_LOCKS} GREATER 0) add_definitions(-DNANO_TIMED_LOCKS=${NANO_TIMED_LOCKS}) add_definitions(-DNANO_TIMED_LOCKS_FILTER=${NANO_TIMED_LOCKS_FILTER}) diff --git a/ci/build.sh b/ci/build.sh index 7c25a724b5..07976992a4 100755 --- a/ci/build.sh +++ b/ci/build.sh @@ -57,6 +57,7 @@ cmake \ -DACTIVE_NETWORK=nano_${NANO_NETWORK:-"live"}_network \ -DNANO_TEST=${NANO_TEST:-OFF} \ -DNANO_GUI=${NANO_GUI:-OFF} \ +-DNANO_TRACING=${NANO_TRACING:-OFF} \ -DCOVERAGE=${COVERAGE:-OFF} \ -DCI_TAG=${CI_TAG:-OFF} \ -DCI_VERSION_PRE_RELEASE=${CI_VERSION_PRE_RELEASE:-OFF} \ diff --git a/nano/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt index 623e6f2601..dda4bccab5 100644 --- a/nano/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -26,13 +26,14 @@ add_executable( ipc.cpp ledger.cpp locks.cpp - logger.cpp + logging.cpp message.cpp message_deserializer.cpp memory_pool.cpp network.cpp network_filter.cpp node.cpp + object_stream.cpp optimistic_scheduler.cpp processing_queue.cpp processor_service.cpp diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 24450b7802..74b520f4fa 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -303,6 +303,6 @@ TEST (election, continuous_voting) ASSERT_TRUE (nano::test::process (node1, { send2 })); ASSERT_TIMELY (5s, node1.active.active (*send2)); - // Ensure votes are generated in continuous manner - ASSERT_TIMELY (5s, node1.stats.count (nano::stat::type::election, nano::stat::detail::generate_vote) >= 5); + // Ensure votes are broadcasted in continuous manner + ASSERT_TIMELY (5s, node1.stats.count (nano::stat::type::election, nano::stat::detail::broadcast_vote) >= 5); } diff --git a/nano/core_test/logger.cpp b/nano/core_test/logger.cpp deleted file mode 100644 index a282736058..0000000000 --- a/nano/core_test/logger.cpp +++ /dev/null @@ -1,16 +0,0 @@ - -#include -#include - -#include - -#include -#include -#include - -using namespace std::chrono_literals; - -TEST (logger, basic) -{ - // TODO -} diff --git a/nano/core_test/logging.cpp b/nano/core_test/logging.cpp new file mode 100644 index 0000000000..0ee857d158 --- /dev/null +++ b/nano/core_test/logging.cpp @@ -0,0 +1,106 @@ +#include +#include + +#include + +#include + +using namespace std::chrono_literals; + +namespace +{ +struct non_copyable +{ + non_copyable () = default; + non_copyable (non_copyable const &) = delete; + non_copyable (non_copyable &&) = default; + non_copyable & operator= (non_copyable const &) = delete; + non_copyable & operator= (non_copyable &&) = default; + + friend std::ostream & operator<< (std::ostream & os, non_copyable const & nc) + { + os << "non_copyable"; + return os; + } +}; +} + +TEST (tracing, no_copy) +{ + non_copyable nc; + + nano::logger logger; + logger.trace (nano::log::type::test, nano::log::detail::test, nano::log::arg{ "non_copyable", nc }); +} + +namespace +{ +struct non_moveable +{ + non_moveable () = default; + non_moveable (non_moveable const &) = delete; + non_moveable (non_moveable &&) = delete; + non_moveable & operator= (non_moveable const &) = delete; + non_moveable & operator= (non_moveable &&) = delete; + + friend std::ostream & operator<< (std::ostream & os, non_moveable const & nm) + { + os << "non_moveable"; + return os; + } +}; +} + +TEST (tracing, no_move) +{ + non_moveable nm; + + nano::logger logger; + logger.trace (nano::log::type::test, nano::log::detail::test, nano::log::arg{ "non_moveable", nm }); +} + +TEST (log_parse, parse_level) +{ + ASSERT_EQ (nano::log::parse_level ("error"), nano::log::level::error); + ASSERT_EQ (nano::log::parse_level ("off"), nano::log::level::off); + ASSERT_THROW (nano::log::parse_level ("enumnotpresent"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_level (""), std::invalid_argument); + ASSERT_THROW (nano::log::parse_level ("_last"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_level ("_error"), std::invalid_argument); +} + +TEST (log_parse, parse_type) +{ + ASSERT_EQ (nano::log::parse_type ("node"), nano::log::type::node); + ASSERT_THROW (nano::log::parse_type ("enumnotpresent"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_type (""), std::invalid_argument); + ASSERT_THROW (nano::log::parse_type ("_last"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_type ("_node"), std::invalid_argument); +} + +TEST (log_parse, parse_detail) +{ + ASSERT_EQ (nano::log::parse_detail ("all"), nano::log::detail::all); + ASSERT_EQ (nano::log::parse_detail ("process_confirmed"), nano::log::detail::process_confirmed); + ASSERT_THROW (nano::log::parse_detail ("enumnotpresent"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_detail (""), std::invalid_argument); + ASSERT_THROW (nano::log::parse_detail ("_last"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_detail ("_all"), std::invalid_argument); +} + +TEST (log_parse, parse_logger_id) +{ + ASSERT_EQ (nano::log::parse_logger_id ("node"), std::make_pair (nano::log::type::node, nano::log::detail::all)); + ASSERT_EQ (nano::log::parse_logger_id ("node::all"), std::make_pair (nano::log::type::node, nano::log::detail::all)); + ASSERT_EQ (nano::log::parse_logger_id ("node::process_confirmed"), std::make_pair (nano::log::type::node, nano::log::detail::process_confirmed)); + ASSERT_THROW (nano::log::parse_logger_id ("_last"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("node::enumnotpresent"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("node::"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("node::_all"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("enumnotpresent"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("invalid."), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("invalid._all"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("::"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id ("::all"), std::invalid_argument); + ASSERT_THROW (nano::log::parse_logger_id (""), std::invalid_argument); +} \ No newline at end of file diff --git a/nano/core_test/object_stream.cpp b/nano/core_test/object_stream.cpp new file mode 100644 index 0000000000..59c09db3bc --- /dev/null +++ b/nano/core_test/object_stream.cpp @@ -0,0 +1,559 @@ +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include + +#include + +namespace +{ +std::string trim (std::string_view str) +{ + return boost::trim_copy (std::string{ str }); +} +} + +TEST (object_stream, primitive_string) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("field_name_1", "field_value"); + + auto expected = R"(field_name_1: "field_value")"; + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_string_view) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("field_name_1", std::string_view{ "field_value" }); + + auto expected = R"(field_name_1: "field_value")"; + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_char) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("field_name_1", 'a'); + + auto expected = R"(field_name_1: "a")"; + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_bool) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("bool_field_1", true); + obs.write ("bool_field_2", false); + + auto expected = trim (R"( +bool_field_1: true, +bool_field_2: false +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_int) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("int_field_1", 1234); + obs.write ("int_field_2", -1234); + obs.write ("int_field_3", std::numeric_limits::max ()); + obs.write ("int_field_4", std::numeric_limits::min ()); + + auto expected = trim (R"( +int_field_1: 1234, +int_field_2: -1234, +int_field_3: 2147483647, +int_field_4: -2147483648 +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_uint) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("uint_field_1", static_cast (1234)); + obs.write ("uint_field_2", static_cast (-1234)); + obs.write ("uint_field_3", std::numeric_limits::max ()); + obs.write ("uint_field_4", std::numeric_limits::min ()); + + auto expected = trim (R"( +uint_field_1: 1234, +uint_field_2: 4294966062, +uint_field_3: 4294967295, +uint_field_4: 0 +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_uint64) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("uint64_field_1", static_cast (1234)); + obs.write ("uint64_field_2", static_cast (-1234)); + obs.write ("uint64_field_3", std::numeric_limits::max ()); + obs.write ("uint64_field_4", std::numeric_limits::min ()); + + auto expected = trim (R"( +uint64_field_1: 1234, +uint64_field_2: 18446744073709550382, +uint64_field_3: 18446744073709551615, +uint64_field_4: 0 +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_int8) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("int8_field_1", static_cast (123)); + + auto expected = R"(int8_field_1: 123)"; + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_uint8) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("uint8_field_1", static_cast (123)); + + auto expected = R"(uint8_field_1: 123)"; + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_float) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("float_field_1", 1234.5678f); + obs.write ("float_field_2", -1234.5678f); + obs.write ("float_field_3", std::numeric_limits::max ()); + obs.write ("float_field_4", std::numeric_limits::min ()); + obs.write ("float_field_5", std::numeric_limits::lowest ()); + + auto expected = trim (R"( +float_field_1: 1234.57, +float_field_2: -1234.57, +float_field_3: 340282346638528859811704183484516925440.00, +float_field_4: 0.00, +float_field_5: -340282346638528859811704183484516925440.00 +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, primitive_double) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("double_field_1", 1234.5678f); + obs.write ("double_field_2", -1234.5678f); + obs.write ("double_field_3", std::numeric_limits::max ()); + obs.write ("double_field_4", std::numeric_limits::min ()); + obs.write ("double_field_5", std::numeric_limits::lowest ()); + + auto expected = trim (R"( +double_field_1: 1234.57, +double_field_2: -1234.57, +double_field_3: 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00, +double_field_4: 0.00, +double_field_5: -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00 +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, object_writer_basic) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("object_field", [] (nano::object_stream & obs) { + obs.write ("field1", "value1"); + obs.write ("field2", "value2"); + obs.write ("field3", true); + obs.write ("field4", 1234); + }); + + auto expected = trim (R"( +object_field: { + field1: "value1", + field2: "value2", + field3: true, + field4: 1234 +} +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, object_writer_nested) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("object_field", [] (nano::object_stream & obs) { + obs.write ("field1", "value1"); + + obs.write ("nested_object", [] (nano::object_stream & obs) { + obs.write ("nested_field1", "nested_value1"); + obs.write ("nested_field2", false); + obs.write ("nested_field3", -1234); + }); + + obs.write ("field2", "value2"); + obs.write ("field3", true); + obs.write ("field4", 1234); + }); + + auto expected = trim (R"( +object_field: { + field1: "value1", + nested_object: { + nested_field1: "nested_value1", + nested_field2: false, + nested_field3: -1234 + }, + field2: "value2", + field3: true, + field4: 1234 +} +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, array_writer_basic) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + obs.write ("array_field", [] (nano::array_stream & ars) { + ars.write (std::views::iota (0, 3)); + }); + + auto expected = trim (R"( +array_field: [ + 0, + 1, + 2 +] +)"); + + ASSERT_EQ (ss.str (), expected); +} + +namespace +{ +class object_basic +{ +public: + nano::uint256_union uint256_union_field{ 0 }; + nano::block_hash block_hash{ 0 }; + + void operator() (nano::object_stream & obs) const + { + obs.write ("uint256_union_field", uint256_union_field); + obs.write ("block_hash", block_hash); + } +}; +} + +TEST (object_stream, object_basic) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + object_basic test_object; + obs.write ("test_object", test_object); + + auto expected = trim (R"( +test_object: { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" +} +)"); + + ASSERT_EQ (ss.str (), expected); +} + +TEST (object_stream, array_writer_objects) +{ + std::stringstream ss; + + std::vector objects; + objects.push_back ({ .block_hash = 0 }); + objects.push_back ({ .block_hash = 1 }); + objects.push_back ({ .block_hash = 2 }); + + nano::object_stream obs{ ss }; + obs.write ("array_field", [&objects] (nano::array_stream & ars) { + ars.write (objects); + }); + + auto expected = trim (R"( +array_field: [ + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000002" + } +] +)"); + + ASSERT_EQ (ss.str (), expected); +} + +namespace +{ +class object_array_basic +{ +public: + std::vector values{ 1, 2, 3 }; + + void operator() (nano::array_stream & ars) const + { + ars.write (values); + } +}; +} + +TEST (object_stream, object_array_basic) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + object_array_basic test_object; + obs.write ("test_object_array", test_object); + + auto expected = trim (R"( +test_object_array: [ + 1, + 2, + 3 +] +)"); + + ASSERT_EQ (ss.str (), expected); +} + +namespace +{ +class object_nested +{ +public: + nano::uint256_union uint256_union_field{ 0 }; + nano::block_hash block_hash{ 0 }; + + object_basic nested_object; + object_array_basic nested_array_object; + + void operator() (nano::object_stream & obs) const + { + obs.write ("uint256_union_field", uint256_union_field); + obs.write ("block_hash", block_hash); + obs.write ("nested_object", nested_object); + obs.write ("nested_array_object", nested_array_object); + } +}; +} + +TEST (object_stream, object_nested) +{ + std::stringstream ss; + + nano::object_stream obs{ ss }; + object_nested test_object; + obs.write ("test_object", test_object); + + auto expected = trim (R"( +test_object: { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000", + nested_object: { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + nested_array_object: [ + 1, + 2, + 3 + ] +} +)"); + + ASSERT_EQ (ss.str (), expected); +} + +namespace nano +{ +using builtin_array_with_pair = std::vector>; + +void stream_as (std::pair const & entry, nano::object_stream & obs) +{ + auto const & [hash, value] = entry; + obs.write ("hash", hash); + obs.write ("value", value); +} +} + +TEST (object_stream, builtin_array) +{ + using namespace nano; + + std::stringstream ss; + + builtin_array_with_pair array; + array.push_back ({ nano::block_hash{ 1 }, 1 }); + array.push_back ({ nano::block_hash{ 2 }, 2 }); + array.push_back ({ nano::block_hash{ 3 }, 3 }); + + nano::object_stream obs{ ss }; + obs.write_range ("array_field", array); + + auto expected = trim (R"( +array_field: [ + { + hash: "0000000000000000000000000000000000000000000000000000000000000001", + value: 1 + }, + { + hash: "0000000000000000000000000000000000000000000000000000000000000002", + value: 2 + }, + { + hash: "0000000000000000000000000000000000000000000000000000000000000003", + value: 3 + } +] +)"); + + ASSERT_EQ (ss.str (), expected); +} + +namespace +{ +class streamable_object +{ +public: + nano::uint256_union uint256_union_field{ 0 }; + nano::block_hash block_hash{ 0 }; + + void operator() (nano::object_stream & obs) const + { + obs.write ("uint256_union_field", uint256_union_field); + obs.write ("block_hash", block_hash); + } +}; +} + +TEST (object_stream, ostream_adapter) +{ + using namespace nano::object_stream_adapters; + + std::stringstream ss1, ss2; + + streamable_object test_object; + ss1 << test_object; // Using automatic ostream adapter (in `nano::ostream_operators`) + ss2 << nano::streamed (test_object); // Using explicit ostream adapter + + auto expected = trim (R"( +{ + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" +} +)"); + + ASSERT_EQ (ss1.str (), expected); + ASSERT_EQ (ss2.str (), expected); +} + +TEST (object_stream, fmt_adapter) +{ + streamable_object test_object; + auto str1 = fmt::format ("{}", test_object); // Using automatic fmt adapter + auto str2 = fmt::format ("{}", nano::streamed (test_object)); // Using explicit fmt adapter + + auto expected = trim (R"( +{ + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" +} +)"); + + ASSERT_EQ (str1, expected); + ASSERT_EQ (str2, expected); +} + +TEST (object_stream, to_string) +{ + using namespace nano::object_stream_adapters; + + streamable_object test_object; + auto str = to_string (test_object); // Using automatic to_string adapter + + auto expected = trim (R"( +{ + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" +} +)"); + + ASSERT_EQ (str, expected); +} + +TEST (object_stream, to_json) +{ + using namespace nano::object_stream_adapters; + + streamable_object test_object; + auto str = to_json (test_object); // Using automatic to_string adapter + + auto expected = trim (R"( +{"uint256_union_field":"0000000000000000000000000000000000000000000000000000000000000000","block_hash":"0000000000000000000000000000000000000000000000000000000000000000"} +)"); + + ASSERT_EQ (str, expected); +} \ No newline at end of file diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 84fa0e1a6a..e93429ead3 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -58,6 +58,9 @@ add_library( memory.cpp numbers.hpp numbers.cpp + object_stream.hpp + object_stream.cpp + object_stream_adapters.hpp observer_set.hpp optional_ptr.hpp processing_queue.hpp diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 7a77dfc3b7..3a13bb3868 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -45,6 +45,10 @@ void nano::block_memory_pool_purge () nano::purge_shared_ptr_singleton_pool_memory (); } +/* + * block + */ + std::string nano::block::to_json () const { std::string result; @@ -183,7 +187,7 @@ nano::account const & nano::block::account () const nano::qualified_root nano::block::qualified_root () const { - return nano::qualified_root (root (), previous ()); + return { root (), previous () }; } nano::amount const & nano::block::balance () const @@ -192,6 +196,21 @@ nano::amount const & nano::block::balance () const return amount; } +void nano::block::operator() (nano::object_stream & obs) const +{ + obs.write ("type", type ()); + obs.write ("hash", hash ()); + + if (has_sideband ()) + { + obs.write ("sideband", sideband ()); + } +} + +/* + * send_block + */ + void nano::send_block::visit (nano::block_visitor & visitor_a) const { visitor_a.send_block (*this); @@ -472,6 +491,21 @@ void nano::send_block::signature_set (nano::signature const & signature_a) signature = signature_a; } +void nano::send_block::operator() (nano::object_stream & obs) const +{ + nano::block::operator() (obs); // Write common data + + obs.write ("previous", hashables.previous); + obs.write ("destination", hashables.destination); + obs.write ("balance", hashables.balance); + obs.write ("signature", signature); + obs.write ("work", work); +} + +/* + * open_block + */ + nano::open_hashables::open_hashables (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a) : source (source_a), representative (representative_a), @@ -748,6 +782,21 @@ void nano::open_block::signature_set (nano::signature const & signature_a) signature = signature_a; } +void nano::open_block::operator() (nano::object_stream & obs) const +{ + nano::block::operator() (obs); // Write common data + + obs.write ("source", hashables.source); + obs.write ("representative", hashables.representative); + obs.write ("account", hashables.account); + obs.write ("signature", signature); + obs.write ("work", work); +} + +/* + * change_block + */ + nano::change_hashables::change_hashables (nano::block_hash const & previous_a, nano::account const & representative_a) : previous (previous_a), representative (representative_a) @@ -999,6 +1048,20 @@ void nano::change_block::signature_set (nano::signature const & signature_a) signature = signature_a; } +void nano::change_block::operator() (nano::object_stream & obs) const +{ + nano::block::operator() (obs); // Write common data + + obs.write ("previous", hashables.previous); + obs.write ("representative", hashables.representative); + obs.write ("signature", signature); + obs.write ("work", work); +} + +/* + * state_block + */ + nano::state_hashables::state_hashables (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a) : account (account_a), previous (previous_a), @@ -1319,6 +1382,23 @@ void nano::state_block::signature_set (nano::signature const & signature_a) signature = signature_a; } +void nano::state_block::operator() (nano::object_stream & obs) const +{ + nano::block::operator() (obs); // Write common data + + obs.write ("account", hashables.account); + obs.write ("previous", hashables.previous); + obs.write ("representative", hashables.representative); + obs.write ("balance", hashables.balance); + obs.write ("link", hashables.link); + obs.write ("signature", signature); + obs.write ("work", work); +} + +/* + * + */ + std::shared_ptr nano::deserialize_block_json (boost::property_tree::ptree const & tree_a, nano::block_uniquer * uniquer_a) { std::shared_ptr result; @@ -1428,6 +1508,10 @@ std::shared_ptr nano::deserialize_block (nano::stream & stream_a, n return result; } +/* + * receive_block + */ + void nano::receive_block::visit (nano::block_visitor & visitor_a) const { visitor_a.receive_block (*this); @@ -1683,6 +1767,20 @@ void nano::receive_hashables::hash (blake2b_state & hash_a) const blake2b_update (&hash_a, source.bytes.data (), sizeof (source.bytes)); } +void nano::receive_block::operator() (nano::object_stream & obs) const +{ + nano::block::operator() (obs); // Write common data + + obs.write ("previous", hashables.previous); + obs.write ("source", hashables.source); + obs.write ("signature", signature); + obs.write ("work", work); +} + +/* + * block_details + */ + nano::block_details::block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a) : epoch (epoch_a), is_send (is_send_a), is_receive (is_receive_a), is_epoch (is_epoch_a) { @@ -1734,6 +1832,14 @@ bool nano::block_details::deserialize (nano::stream & stream_a) return result; } +void nano::block_details::operator() (nano::object_stream & obs) const +{ + obs.write ("epoch", epoch); + obs.write ("is_send", is_send); + obs.write ("is_receive", is_receive); + obs.write ("is_epoch", is_epoch); +} + std::string nano::state_subtype (nano::block_details const details_a) { debug_assert (details_a.is_epoch + details_a.is_receive + details_a.is_send <= 1); @@ -1755,6 +1861,10 @@ std::string nano::state_subtype (nano::block_details const details_a) } } +/* + * block_sideband + */ + nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, nano::seconds_t const timestamp_a, nano::block_details const & details_a, nano::epoch const source_epoch_a) : successor (successor_a), account (account_a), @@ -1866,6 +1976,17 @@ bool nano::block_sideband::deserialize (nano::stream & stream_a, nano::block_typ return result; } +void nano::block_sideband::operator() (nano::object_stream & obs) const +{ + obs.write ("successor", successor); + obs.write ("account", account); + obs.write ("balance", balance); + obs.write ("height", height); + obs.write ("timestamp", timestamp); + obs.write ("source_epoch", source_epoch); + obs.write ("details", details); +} + std::string_view nano::to_string (nano::block_type type) { return magic_enum::enum_name (type); diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index acc44601d5..19c31d95eb 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -19,6 +20,7 @@ namespace nano { class block_visitor; class mutable_block_visitor; + enum class block_type : uint8_t { invalid = 0, @@ -55,6 +57,9 @@ class block_details private: uint8_t packed () const; void unpack (uint8_t); + +public: // Logging + void operator() (nano::object_stream &) const; }; std::string state_subtype (nano::block_details const); @@ -75,7 +80,11 @@ class block_sideband final uint64_t timestamp{ 0 }; nano::block_details details; nano::epoch source_epoch{ nano::epoch::epoch_0 }; + +public: // Logging + void operator() (nano::object_stream &) const; }; + class block { public: @@ -132,6 +141,9 @@ class block private: nano::block_hash generate_hash () const; + +public: // Logging + virtual void operator() (nano::object_stream &) const; }; using block_list_t = std::vector>; @@ -149,6 +161,7 @@ class send_hashables nano::amount balance; static std::size_t constexpr size = sizeof (previous) + sizeof (destination) + sizeof (balance); }; + class send_block : public nano::block { public: @@ -182,7 +195,11 @@ class send_block : public nano::block nano::signature signature; uint64_t work; static std::size_t constexpr size = nano::send_hashables::size + sizeof (signature) + sizeof (work); + +public: // Logging + void operator() (nano::object_stream &) const override; }; + class receive_hashables { public: @@ -195,6 +212,7 @@ class receive_hashables nano::block_hash source; static std::size_t constexpr size = sizeof (previous) + sizeof (source); }; + class receive_block : public nano::block { public: @@ -227,7 +245,11 @@ class receive_block : public nano::block nano::signature signature; uint64_t work; static std::size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); + +public: // Logging + void operator() (nano::object_stream &) const override; }; + class open_hashables { public: @@ -241,6 +263,7 @@ class open_hashables nano::account account; static std::size_t constexpr size = sizeof (source) + sizeof (representative) + sizeof (account); }; + class open_block : public nano::block { public: @@ -276,7 +299,11 @@ class open_block : public nano::block nano::signature signature; uint64_t work; static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); + +public: // Logging + void operator() (nano::object_stream &) const override; }; + class change_hashables { public: @@ -289,6 +316,7 @@ class change_hashables nano::account representative; static std::size_t constexpr size = sizeof (previous) + sizeof (representative); }; + class change_block : public nano::block { public: @@ -321,7 +349,11 @@ class change_block : public nano::block nano::signature signature; uint64_t work; static std::size_t constexpr size = nano::change_hashables::size + sizeof (signature) + sizeof (work); + +public: // Logging + void operator() (nano::object_stream &) const override; }; + class state_hashables { public: @@ -347,6 +379,7 @@ class state_hashables // Serialized size static std::size_t constexpr size = sizeof (account) + sizeof (previous) + sizeof (representative) + sizeof (balance) + sizeof (link); }; + class state_block : public nano::block { public: @@ -382,7 +415,11 @@ class state_block : public nano::block nano::signature signature; uint64_t work; static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); + +public: // Logging + void operator() (nano::object_stream &) const override; }; + class block_visitor { public: diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 2860d76eb8..7fbfb0b6e0 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include @@ -23,6 +24,7 @@ nano::logger & nano::default_logger () bool nano::logger::global_initialized{ false }; nano::log_config nano::logger::global_config{}; std::vector nano::logger::global_sinks{}; +nano::object_stream_config nano::logger::global_tracing_config{}; // By default, use only the tag as the logger name, since only one node is running in the process std::function nano::logger::global_name_formatter{ [] (nano::log::logger_id logger_id, std::string identifier) { @@ -43,7 +45,6 @@ namespace /// Takes a qualified identifier in the form `node_identifier::tag` and splits it into a pair of `identifier` and `tag` /// It is a limitation of spldlog that we cannot attach additional data to the logger, so we have to encode the node identifier in the logger name /// @returns - std::pair split_qualified_identifier (std::string_view qualified_identifier) { auto pos = qualified_identifier.find ("::"); @@ -185,6 +186,17 @@ void nano::logger::initialize_common (nano::log_config const & config, std::opti global_sinks.push_back (file_sink); } } + + // Tracing setup + switch (config.tracing_format) + { + case nano::log::tracing_format::standard: + global_tracing_config = nano::object_stream_config::default_config (); + break; + case nano::log::tracing_format::json: + global_tracing_config = nano::object_stream_config::json_config (); + break; + } } void nano::logger::flush () @@ -453,9 +465,10 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi { try { - config.default_level = nano::log::parse_level (*env_level); + auto level = nano::log::parse_level (*env_level); + config.default_level = level; - std::cerr << "Using default log level from NANO_LOG environment variable: " << *env_level << std::endl; + std::cerr << "Using default log level from NANO_LOG environment variable: " << to_string (level) << std::endl; } catch (std::invalid_argument const & ex) { @@ -487,7 +500,7 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi levels[logger_id] = logger_level; - std::cerr << "Using logger log level from NANO_LOG_LEVELS environment variable: " << name_str << "=" << level_str << std::endl; + std::cerr << "Using logger log level from NANO_LOG_LEVELS environment variable: " << to_string (logger_id) << "=" << to_string (logger_level) << std::endl; } catch (std::invalid_argument const & ex) { @@ -502,6 +515,42 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi } } + auto env_tracing_format = nano::get_env ("NANO_TRACE_FORMAT"); + if (env_tracing_format) + { + try + { + auto tracing_format = nano::log::parse_tracing_format (*env_tracing_format); + config.tracing_format = tracing_format; + + std::cerr << "Using trace format from NANO_TRACE_FORMAT environment variable: " << to_string (tracing_format) << std::endl; + } + catch (std::invalid_argument const & ex) + { + std::cerr << "Invalid trace format from NANO_TRACE_FORMAT environment variable: " << ex.what () << std::endl; + } + } + + auto tracing_configured = [&] () { + if (config.default_level == nano::log::level::trace) + { + return true; + } + for (auto const & [logger_id, level] : config.levels) + { + if (level == nano::log::level::trace) + { + return true; + } + } + return false; + }; + + if (tracing_configured () && !is_tracing_enabled ()) + { + std::cerr << "WARNING: Tracing is not enabled in this build, but log level is set to trace" << std::endl; + } + return config; } catch (std::runtime_error const & ex) diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 00b1cddbab..8a77dae27d 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -1,6 +1,8 @@ #pragma once #include +#include +#include #include #include @@ -8,10 +10,24 @@ #include #include +#include #include namespace nano::log { +template +struct arg +{ + std::string_view name; + T const & value; + + arg (std::string_view name_a, T const & value_a) : + name{ name_a }, + value{ value_a } + { + } +}; + using logger_id = std::pair; std::string to_string (logger_id); @@ -20,6 +36,15 @@ logger_id parse_logger_id (std::string const &); namespace nano { +consteval bool is_tracing_enabled () +{ +#ifdef NANO_TRACING + return true; +#else + return false; +#endif +} + class log_config final { public: @@ -53,6 +78,8 @@ class log_config final console_config console; file_config file; + nano::log::tracing_format tracing_format{ nano::log::tracing_format::standard }; + public: // Predefined defaults static log_config cli_default (); static log_config daemon_default (); @@ -76,7 +103,7 @@ class logger final logger (logger const &) = delete; public: - static void initialize (nano::log_config fallback, std::optional data_path = std::nullopt, std::vector const & config_overrides = std::vector ()); + static void initialize (nano::log_config fallback, std::optional data_path = std::nullopt, std::vector const & config_overrides = {}); static void initialize_for_tests (nano::log_config fallback); static void flush (); @@ -85,6 +112,7 @@ class logger final static nano::log_config global_config; static std::vector global_sinks; static std::function global_name_formatter; + static nano::object_stream_config global_tracing_config; static void initialize_common (nano::log_config const &, std::optional data_path); @@ -125,6 +153,28 @@ class logger final get_logger (type).critical (fmt, std::forward (args)...); } +public: + template + void trace (nano::log::type type, nano::log::detail detail, Args &&... args) + { + if constexpr (is_tracing_enabled ()) + { + debug_assert (detail != nano::log::detail::all); + + // Include info about precise time of the event + auto now = std::chrono::high_resolution_clock::now (); + auto now_micros = std::chrono::duration_cast (now.time_since_epoch ()).count (); + + // TODO: Improve code indentation config + auto logger = get_logger (type, detail); + logger.trace ("{}", + nano::streamed_args (global_tracing_config, + nano::log::arg{ "event", to_string (std::make_pair (type, detail)) }, + nano::log::arg{ "time", now_micros }, + std::forward (args)...)); + } + } + private: const std::string identifier; diff --git a/nano/lib/logging_enums.cpp b/nano/lib/logging_enums.cpp index a7bbd1c7ba..7111ca6591 100644 --- a/nano/lib/logging_enums.cpp +++ b/nano/lib/logging_enums.cpp @@ -75,4 +75,39 @@ nano::log::detail nano::log::parse_detail (std::string_view name) { throw std::invalid_argument ("Invalid log detail: " + std::string (name)); } +} + +std::string_view nano::log::to_string (nano::log::tracing_format format) +{ + return magic_enum::enum_name (format); +} + +nano::log::tracing_format nano::log::parse_tracing_format (std::string_view name) +{ + auto value = magic_enum::enum_cast (name); + if (value.has_value ()) + { + return value.value (); + } + else + { + auto all_formats_str = nano::util::join (nano::log::all_tracing_formats (), ", ", [] (auto const & fmt) { + return to_string (fmt); + }); + + throw std::invalid_argument ("Invalid tracing format: " + std::string (name) + ". Must be one of: " + all_formats_str); + } +} + +const std::vector & nano::log::all_tracing_formats () +{ + static std::vector all = [] () { + std::vector result; + for (auto const & fmt : magic_enum::enum_values ()) + { + result.push_back (fmt); + } + return result; + }(); + return all; } \ No newline at end of file diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index af2ebfda84..d3df7ed774 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -24,6 +24,7 @@ enum class type all = 0, // reserved generic, + test, init, config, logging, @@ -46,7 +47,9 @@ enum class type election, blockprocessor, network, + network_processed, channel, + channel_sent, socket, socket_server, tcp, @@ -65,6 +68,10 @@ enum class type txn_tracker, gap_cache, vote_processor, + election_scheduler, + vote_generator, + + // bootstrap bulk_pull_client, bulk_pull_server, bulk_pull_account_client, @@ -84,6 +91,8 @@ enum class detail { all = 0, // reserved + test, + // node process_confirmed, @@ -94,6 +103,7 @@ enum class detail // election election_confirmed, election_expired, + broadcast_vote, // blockprocessor block_processed, @@ -102,10 +112,17 @@ enum class detail vote_processed, // network - message_received, + message_processed, message_sent, message_dropped, + // election_scheduler + block_activated, + + // vote_generator + candidate_processed, + should_vote, + // bulk pull/push pulled_block, sending_block, @@ -114,6 +131,24 @@ enum class detail requesting_account_or_head, requesting_pending, + // message types + not_a_type, + invalid, + keepalive, + publish, + republish_vote, + confirm_req, + confirm_ack, + node_id_handshake, + telemetry_req, + telemetry_ack, + asc_pull_req, + asc_pull_ack, + bulk_pull, + bulk_push, + frontier_req, + bulk_pull_account, + _last // Must be the last enum }; @@ -127,6 +162,12 @@ enum class category _last // Must be the last enum }; + +enum class tracing_format +{ + standard, + json, +}; } namespace nano::log @@ -146,6 +187,10 @@ nano::log::detail parse_detail (std::string_view); std::vector const & all_levels (); std::vector const & all_types (); + +std::string_view to_string (nano::log::tracing_format); +nano::log::tracing_format parse_tracing_format (std::string_view); +std::vector const & all_tracing_formats (); } // Ensure that the enum_range is large enough to hold all values (including future ones) diff --git a/nano/lib/object_stream.cpp b/nano/lib/object_stream.cpp new file mode 100644 index 0000000000..b733fc0eca --- /dev/null +++ b/nano/lib/object_stream.cpp @@ -0,0 +1,28 @@ +#include + +nano::object_stream_config const & nano::object_stream_config::default_config () +{ + static object_stream_config const config{}; + return config; +} + +nano::object_stream_config const & nano::object_stream_config::json_config () +{ + static object_stream_config const config{ + .field_name_begin = "\"", + .field_name_end = "\"", + .field_assignment = ":", + .field_separator = ",", + .object_begin = "{", + .object_end = "}", + .array_begin = "[", + .array_end = "]", + .array_element_begin = "", + .array_element_end = "", + .array_element_separator = ",", + .indent = "", + .newline = "", + .precision = 4, + }; + return config; +} \ No newline at end of file diff --git a/nano/lib/object_stream.hpp b/nano/lib/object_stream.hpp new file mode 100644 index 0000000000..02b20bf44b --- /dev/null +++ b/nano/lib/object_stream.hpp @@ -0,0 +1,555 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace nano +{ +struct object_stream_config +{ + std::string field_name_begin{ "" }; + std::string field_name_end{ "" }; + std::string field_assignment{ ": " }; + std::string field_separator{ "," }; + + std::string object_begin{ "{" }; + std::string object_end{ "}" }; + + std::string array_begin{ "[" }; + std::string array_end{ "]" }; + + std::string array_element_begin{ "" }; + std::string array_element_end{ "" }; + std::string array_element_separator{ "," }; + + std::string string_begin{ "\"" }; + std::string string_end{ "\"" }; + + std::string true_value{ "true" }; + std::string false_value{ "false" }; + std::string null_value{ "null" }; + + std::string indent{ "\t" }; + std::string newline{ "\n" }; + + /** Number of decimal places to show for `float` and `double` */ + int precision{ 2 }; + + static object_stream_config const & default_config (); + static object_stream_config const & json_config (); +}; + +class object_stream_context +{ +public: + object_stream_config const & config; + + explicit object_stream_context (std::ostream & os, object_stream_config const & config = object_stream_config::default_config ()) : + os{ os }, + config{ config } + { + } + + // Bump indent level when nesting objects + object_stream_context (object_stream_context const & other) : + os{ other.os }, + config{ other.config }, + indent_level{ other.indent_level + 1 } + { + } + +private: + std::ostream & os; + int indent_level{ 0 }; + bool needs_newline{ false }; + +public: // Keep these defined in the header for inlining + std::ostream & begin_stream () + { + return os; + } + + void begin_field (std::string_view name, bool first) + { + if (!first) + { + os << config.field_separator; + } + if (std::exchange (needs_newline, false)) + { + os << config.newline; + } + indent (); + os << config.field_name_begin << name << config.field_name_end << config.field_assignment; + } + + void end_field () + { + needs_newline = true; + } + + void begin_object () + { + os << config.object_begin; + os << config.newline; + } + + void end_object () + { + os << config.newline; + indent (); + os << config.object_end; + needs_newline = true; + } + + void begin_array () + { + os << config.array_begin; + os << config.newline; + } + + void end_array () + { + os << config.newline; + indent (); + os << config.array_end; + needs_newline = true; + } + + void begin_array_element (bool first) + { + if (!first) + { + os << config.array_element_separator; + } + if (std::exchange (needs_newline, false)) + { + os << config.newline; + } + indent (); + os << config.array_element_begin; + } + + void end_array_element () + { + os << config.array_element_end; + needs_newline = true; + } + + void begin_string () + { + os << config.string_begin; + } + + void end_string () + { + os << config.string_end; + } + +private: + void indent () + { + if (!config.indent.empty ()) + { + for (int i = 0; i < indent_level; ++i) + { + os << config.indent; + } + } + } +}; + +class object_stream; +class array_stream; + +/* + * Concepts used for choosing the correct writing function + */ + +template +concept object_streamable = requires (T const & obj, object_stream & obs) { + { + stream_as (obj, obs) + }; +}; + +template +concept array_streamable = requires (T const & obj, array_stream & ars) { + { + stream_as (obj, ars) + }; +}; + +template +concept object_or_array_streamable = object_streamable || array_streamable; + +class object_stream_base +{ +public: + explicit object_stream_base (object_stream_context const & ctx) : + ctx{ ctx } + { + } + + explicit object_stream_base (std::ostream & os, object_stream_config const & config = object_stream_config::default_config ()) : + ctx{ os, config } + { + } + +protected: + object_stream_context ctx; +}; + +/** + * Used to serialize an object. + * Outputs: `field1: value1, field2: value2, ...` (without enclosing `{}`) + */ +class object_stream : private object_stream_base +{ +public: + // Inherit default constructors + using object_stream_base::object_stream_base; + + object_stream (object_stream const &) = delete; // Disallow copying + +public: + template + void write (std::string_view name, Value const & value) + { + ctx.begin_field (name, std::exchange (first_field, false)); + stream_as_value (value, ctx); + ctx.end_field (); + } + + // Handle `.write_range ("name", container)` + template + inline void write_range (std::string_view name, Container const & container); + + // Handle `.write_range ("name", container, [] (auto const & entry) { ... })` + template + requires (std::is_invocable_v) + void write_range (std::string_view name, Container const & container, Transform transform) + { + write_range (name, std::views::transform (container, transform)); + } + + // Handle `.write_range ("name", container, [] (auto const & entry, nano::object_stream &) { ... })` + template + requires (std::is_invocable_v) + void write_range (std::string_view name, Container const & container, Writer writer) + { + write_range (name, container, [&writer] (auto const & el) { + return [&writer, &el] (object_stream & obs) { + writer (el, obs); + }; + }); + } + + // Handle `.write_range ("name", container, [] (auto const & entry, nano::array_stream &) { ... })` + template + requires (std::is_invocable_v) + void write_range (std::string_view name, Container const & container, Writer writer) + { + write_range (name, container, [&writer] (auto const & el) { + return [&writer, &el] (array_stream & obs) { + writer (el, obs); + }; + }); + } + +private: + bool first_field{ true }; +}; + +/** + * Used to serialize an array of objects. + * Outputs: `[value1, value2, ...]` + */ +class array_stream : private object_stream_base +{ +public: + // Inherit default constructors + using object_stream_base::object_stream_base; + + array_stream (array_stream const &) = delete; // Disallow copying + +private: + template + void write_single (Value const & value) + { + ctx.begin_array_element (std::exchange (first_element, false)); + stream_as_value (value, ctx); + ctx.end_array_element (); + } + +public: + // Handle `.write (container)` + template + void write (Container const & container) + { + for (auto const & el : container) + { + write_single (el); + }; + } + + // Handle `.write (container, [] (auto const & entry) { ... })` + template + requires (std::is_invocable_v) + void write (Container const & container, Transform transform) + { + write (std::views::transform (container, transform)); + } + + // Handle `.write (container, [] (auto const & entry, nano::object_stream &) { ... })` + template + requires (std::is_invocable_v) + void write (Container const & container, Writer writer) + { + write (container, [&writer] (auto const & el) { + return [&writer, &el] (object_stream & obs) { + writer (el, obs); + }; + }); + } + + // Handle `.write_range (container, [] (auto const & entry, nano::array_stream &) { ... })` + template + requires (std::is_invocable_v) + void write (Container const & container, Writer writer) + { + write (container, [&writer] (auto const & el) { + return [&writer, &el] (array_stream & obs) { + writer (el, obs); + }; + }); + } + +private: + bool first_element{ true }; +}; + +/** + * Used for human readable object serialization. Should be used to serialize a single object. + * Outputs: `{ field1: value1, field2: value2, ... }` + */ +class root_object_stream : private object_stream_base +{ +public: + // Inherit default constructors + using object_stream_base::object_stream_base; + +public: + template + void write (Value const & value) + { + stream_as_value (value, ctx); + } + + // Handle `.write_range (container)` + template + inline void write_range (Container const & container); + + // Handle `.write_range (container, [] (auto const & entry) { ... })` + template + requires (std::is_invocable_v) + void write_range (Container const & container, Transform transform) + { + write_range (std::views::transform (container, transform)); + } + + // Handle `.write_range (container, [] (auto const & entry, nano::object_stream &) { ... })` + template + requires (std::is_invocable_v) + void write_range (Container const & container, Writer writer) + { + write_range (container, [&writer] (auto const & el) { + return [&writer, &el] (object_stream & obs) { + writer (el, obs); + }; + }); + } + + // Handle `.write_range (container, [] (auto const & entry, nano::array_stream &) { ... })` + template + requires (std::is_invocable_v) + void write_range (Container const & container, Writer writer) + { + write_range (container, [&writer] (auto const & el) { + return [&writer, &el] (array_stream & obs) { + writer (el, obs); + }; + }); + } +}; + +/* + * Implementation for `write_range` functions + */ + +template +inline void nano::object_stream::write_range (std::string_view name, Container const & container) +{ + write (name, [&container] (array_stream & ars) { + ars.write (container); + }); +} + +template +inline void nano::root_object_stream::write_range (Container const & container) +{ + write ([&container] (array_stream & ars) { + ars.write (container); + }); +} + +/* + * Writers + */ + +template +inline void stream_as_value (Value const & value, object_stream_context & ctx) +{ + // Automatically support printing all enums + using magic_enum::iostream_operators::operator<<; + + ctx.begin_string (); + ctx.begin_stream () << value; // Write using type specific ostream operator + ctx.end_string (); +} + +template +inline void stream_as_value (Value const & value, object_stream_context & ctx) +{ + ctx.begin_object (); + + // Write as object + nano::object_stream obs{ ctx }; + stream_as (value, obs); + + ctx.end_object (); +} + +template +inline void stream_as_value (Value const & value, object_stream_context & ctx) +{ + ctx.begin_array (); + + // Write as array + nano::array_stream ars{ ctx }; + stream_as (value, ars); + + ctx.end_array (); +} + +/* + * Adapters for types implementing convenience `obj(object_stream &)` & `obj(array_stream &)` functions + */ + +template +concept simple_object_streamable = requires (T const & obj, object_stream & obs) { + { + obj (obs) + }; +}; + +template +concept simple_array_streamable = requires (T const & obj, array_stream & ars) { + { + obj (ars) + }; +}; + +template +inline void stream_as (Value const & value, object_stream & obs) +{ + value (obs); +} + +template +inline void stream_as (Value const & value, array_stream & ars) +{ + value (ars); +} +} + +/* + * Specializations for primitive types + */ + +namespace nano +{ +template + requires (std::is_integral_v && sizeof (Value) > 1) // Exclude bool, char, etc. +inline void stream_as_value (const Value & value, object_stream_context & ctx) +{ + ctx.begin_stream () << value; +} + +template + requires (std::is_floating_point_v) +inline void stream_as_value (const Value & value, object_stream_context & ctx) +{ + ctx.begin_stream () << std::fixed << std::setprecision (ctx.config.precision) << value; +} + +inline void stream_as_value (bool const & value, object_stream_context & ctx) +{ + ctx.begin_stream () << (value ? ctx.config.true_value : ctx.config.false_value); +} + +inline void stream_as_value (const int8_t & value, object_stream_context & ctx) +{ + ctx.begin_stream () << static_cast (value); // Avoid printing as char +} + +inline void stream_as_value (const uint8_t & value, object_stream_context & ctx) +{ + ctx.begin_stream () << static_cast (value); // Avoid printing as char +} + +template +inline void stream_as_optional (const Opt & opt, object_stream_context & ctx) +{ + if (opt) + { + stream_as_value (*opt, ctx); + } + else + { + ctx.begin_stream () << ctx.config.null_value; + } +} + +template +inline void stream_as_value (std::shared_ptr const & value, object_stream_context & ctx) +{ + stream_as_optional (value, ctx); +} + +template +inline void stream_as_value (std::unique_ptr const & value, object_stream_context & ctx) +{ + stream_as_optional (value, ctx); +} + +template +inline void stream_as_value (std::weak_ptr const & value, object_stream_context & ctx) +{ + stream_as_optional (value.lock (), ctx); +} + +template +inline void stream_as_value (std::optional const & value, object_stream_context & ctx) +{ + stream_as_optional (value, ctx); +} +} \ No newline at end of file diff --git a/nano/lib/object_stream_adapters.hpp b/nano/lib/object_stream_adapters.hpp new file mode 100644 index 0000000000..8be5b445f4 --- /dev/null +++ b/nano/lib/object_stream_adapters.hpp @@ -0,0 +1,127 @@ +#pragma once + +#include + +#include +#include + +#include + +namespace nano +{ +template +struct object_stream_formatter +{ + nano::object_stream_config const & config; + Streamable const & value; + + explicit object_stream_formatter (Streamable const & value, nano::object_stream_config const & config) : + config{ config }, + value{ value } + { + } + + friend std::ostream & operator<< (std::ostream & os, object_stream_formatter const & self) + { + nano::root_object_stream obs{ os, self.config }; + obs.write (self.value); + return os; + } + + // Needed for fmt formatting, uses the ostream operator under the hood + friend auto format_as (object_stream_formatter const & val) + { + return fmt::streamed (val); + } +}; + +template +auto streamed (Streamable const & value) +{ + return object_stream_formatter{ value, nano::object_stream_config::default_config () }; +} + +template +auto streamed_as_json (Streamable const & value) +{ + return object_stream_formatter{ value, nano::object_stream_config::json_config () }; +} + +/** + * Wraps {name,value} args and provides `<<(std::ostream &, ...)` and fmt format operator that writes the arguments to the stream in a lazy manner. + */ +template +struct object_stream_args_formatter +{ + nano::object_stream_config const & config; + std::tuple args; + + explicit object_stream_args_formatter (nano::object_stream_config const & config, Args &&... args) : + config{ config }, + args{ std::forward (args)... } + { + } + + friend std::ostream & operator<< (std::ostream & os, object_stream_args_formatter const & self) + { + nano::object_stream obs{ os, self.config }; + std::apply ([&obs] (auto &&... args) { + ((obs.write (args.name, args.value)), ...); + }, + self.args); + return os; + } + + // Needed for fmt formatting, uses the ostream operator under the hood + friend auto format_as (object_stream_args_formatter const & val) + { + return fmt::streamed (val); + } +}; + +template +auto streamed_args (nano::object_stream_config const & config, Args &&... args) +{ + return object_stream_args_formatter{ config, std::forward (args)... }; +} +} + +/* + * Adapter that allows for printing using '<<' operator for all classes that implement object streaming + */ +namespace nano::object_stream_adapters +{ +template +std::ostream & operator<< (std::ostream & os, Value const & value) +{ + return os << nano::streamed (value); +} + +template +std::string to_string (Value const & value) +{ + std::stringstream ss; + ss << nano::streamed (value); + return ss.str (); +} + +template +std::string to_json (Value const & value) +{ + std::stringstream ss; + ss << nano::streamed_as_json (value); + return ss.str (); +} +} + +/* + * Adapter that allows for printing using fmt library for all classes that implement object streaming + */ +template +struct fmt::formatter : fmt::ostream_formatter +{ + auto format (Streamable const & value, format_context & ctx) + { + return fmt::ostream_formatter::format (nano::streamed (value), ctx); + } +}; \ No newline at end of file diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index b6373996ca..2bfda59d3c 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -152,6 +152,14 @@ enum class detail : uint8_t vote_processed, vote_cached, election_block_conflict, + election_restart, + election_not_confirmed, + election_hinted_overflow, + election_hinted_confirmed, + election_hinted_drop, + broadcast_vote, + broadcast_vote_normal, + broadcast_vote_final, generate_vote, generate_vote_normal, generate_vote_final, diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index a66f69119d..88c85c1e5b 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -322,9 +322,10 @@ void nano::active_transactions::cleanup_election (nano::unique_lock roots.get ().erase (roots.get ().find (election->qualified_root)); - lock_a.unlock (); - node.stats.inc (completion_type (*election), to_stat_detail (election->behavior ())); + node.logger.trace (nano::log::type::active_transactions, nano::log::detail::active_stopped, nano::log::arg{ "election", election }); + + lock_a.unlock (); vacancy_update (); @@ -421,7 +422,9 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p nano::election_insertion_result result; if (stopped) + { return result; + } auto const root = block_a->qualified_root (); auto const hash = block_a->hash (); @@ -442,6 +445,11 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p // Keep track of election count by election type debug_assert (count_by_behavior[result.election->behavior ()] >= 0); count_by_behavior[result.election->behavior ()]++; + + node.stats.inc (nano::stat::type::active_started, to_stat_detail (election_behavior_a)); + node.logger.trace (nano::log::type::active_transactions, nano::log::detail::active_started, + nano::log::arg{ "behavior", election_behavior_a }, + nano::log::arg{ "election", result.election }); } else { @@ -457,11 +465,13 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p if (result.inserted) { + release_assert (result.election); + if (auto const cache = node.vote_cache.find (hash); cache) { cache->fill (result.election); } - node.stats.inc (nano::stat::type::active_started, to_stat_detail (election_behavior_a)); + node.observers.active_started.notify (hash); vacancy_update (); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 76786fd247..27090889c9 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -255,6 +255,10 @@ nano::process_return nano::block_processor::process_one (store::write_transactio result = node.ledger.process (transaction_a, *block); node.stats.inc (nano::stat::type::blockprocessor, to_stat_detail (result.code)); + node.logger.trace (nano::log::type::blockprocessor, nano::log::detail::block_processed, + nano::log::arg{ "result", result.code }, + nano::log::arg{ "forced", forced_a }, + nano::log::arg{ "block", block }); switch (result.code) { diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 33fb6717a2..2fcd9653a2 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -80,6 +80,10 @@ void nano::bulk_pull_client::request () req.count = pull.count; req.set_count_present (pull.count != 0); + node->logger.trace (nano::log::type::bulk_pull_client, nano::log::detail::requesting_account_or_head, + nano::log::arg{ "account_or_head", pull.account_or_head }, + nano::log::arg{ "channel", connection->channel }); + if (attempt->should_log ()) { node->logger.debug (nano::log::type::bulk_pull_client, "Accounts in pull queue: {}", attempt->pulling.load ()); @@ -166,6 +170,8 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: } auto hash = block->hash (); + node->logger.trace (nano::log::type::bulk_pull_client, nano::log::detail::pulled_block, nano::log::arg{ "block", block }); + // Is block expected? bool block_expected (false); // Unconfirmed head is used only for lazy destinations if legacy bootstrap is not available, see nano::bootstrap_attempt::lazy_destinations_increment (...) @@ -232,6 +238,10 @@ void nano::bulk_pull_account_client::request () req.minimum_amount = node->config.receive_minimum; req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount; + node->logger.trace (nano::log::type::bulk_pull_account_client, nano::log::detail::requesting_pending, + nano::log::arg{ "account", req.account.to_account () }, // TODO: Convert to lazy eval + nano::log::arg{ "connection", connection->channel }); + if (attempt->should_log ()) { node->logger.debug (nano::log::type::bulk_pull_account_client, "Accounts in pull queue: {}", attempt->wallet_size ()); @@ -413,6 +423,10 @@ void nano::bulk_pull_server::send_next () auto block = get_next (); if (block != nullptr) { + node->logger.trace (nano::log::type::bulk_pull_server, nano::log::detail::sending_block, + nano::log::arg{ "block", block }, + nano::log::arg{ "socket", connection->socket }); + std::vector send_buffer; { nano::vectorstream stream (send_buffer); @@ -681,11 +695,17 @@ void nano::bulk_pull_account_server::send_next_block () std::vector send_buffer; if (pending_address_only) { + node->logger.trace (nano::log::type::bulk_pull_account_server, nano::log::detail::sending_pending, + nano::log::arg{ "pending", block_info->source }); + nano::vectorstream output_stream (send_buffer); write (output_stream, block_info->source.bytes); } else { + node->logger.trace (nano::log::type::bulk_pull_account_server, nano::log::detail::sending_block, + nano::log::arg{ "block", block_info_key->hash }); + nano::vectorstream output_stream (send_buffer); write (output_stream, block_info_key->hash.bytes); write (output_stream, block_info->amount.bytes); diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 7a9d580361..76fa692177 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -275,6 +275,11 @@ void nano::frontier_req_server::send_next () } if (!current.is_zero () && count < request->count) { + node->logger.trace (nano::log::type::frontier_req_server, nano::log::detail::sending_frontier, + nano::log::arg{ "account", current.to_account () }, // TODO: Convert to lazy eval + nano::log::arg{ "frontier", frontier }, + nano::log::arg{ "socket", connection->socket }); + std::vector send_buffer; { nano::vectorstream stream (send_buffer); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 228da61a94..ae3afd7ce6 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -20,6 +20,10 @@ nano::election_vote_result::election_vote_result (bool replay_a, bool processed_ processed = processed_a; } +/* + * election + */ + nano::election::election (nano::node & node_a, std::shared_ptr const & block_a, std::function const &)> const & confirmation_action_a, std::function const & live_vote_action_a, nano::election_behavior election_behavior_a) : confirmation_action (confirmation_action_a), live_vote_action (live_vote_action_a), @@ -56,6 +60,11 @@ void nano::election::confirm_once (nano::unique_lock & lock_a, nano node.active.recently_confirmed.put (qualified_root, status_l.winner->hash ()); + node.logger.trace (nano::log::type::election, nano::log::detail::election_confirmed, + nano::log::arg{ "id", id }, + nano::log::arg{ "qualified_root", qualified_root }, + nano::log::arg{ "status", current_status_locked () }); + lock_a.unlock (); node.background ([node_l = node.shared (), status_l, confirmation_action_l = confirmation_action] () { @@ -251,6 +260,11 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a // state_change returning true would indicate it if (!state_change (state_m, nano::election::state_t::expired_unconfirmed)) { + node.logger.trace (nano::log::type::election, nano::log::detail::election_expired, + nano::log::arg{ "id", id }, + nano::log::arg{ "qualified_root", qualified_root }, + nano::log::arg{ "status", current_status_locked () }); + result = true; // Return true to indicate this election should be cleaned up status.type = nano::election_status_type::stopped; } @@ -458,6 +472,7 @@ nano::election_vote_result nano::election::vote (nano::account const & rep, uint return nano::election_vote_result (false, false); } } + last_votes[rep] = { std::chrono::steady_clock::now (), timestamp_a, block_hash_a }; if (vote_source_a == vote_source::live) { @@ -465,6 +480,15 @@ nano::election_vote_result nano::election::vote (nano::account const & rep, uint } node.stats.inc (nano::stat::type::election, vote_source_a == vote_source::live ? nano::stat::detail::vote_new : nano::stat::detail::vote_cached); + node.logger.trace (nano::log::type::election, nano::log::detail::vote_processed, + nano::log::arg{ "id", id }, + nano::log::arg{ "qualified_root", qualified_root }, + nano::log::arg{ "account", rep }, + nano::log::arg{ "hash", block_hash_a }, + nano::log::arg{ "final", nano::vote::is_final_timestamp (timestamp_a) }, + nano::log::arg{ "timestamp", timestamp_a }, + nano::log::arg{ "vote_source", vote_source_a }, + nano::log::arg{ "weight", weight }); if (!confirmed_locked ()) { @@ -518,11 +542,18 @@ bool nano::election::publish (std::shared_ptr const & block_a) nano::election_extended_status nano::election::current_status () const { nano::lock_guard guard{ mutex }; + return current_status_locked (); +} + +nano::election_extended_status nano::election::current_status_locked () const +{ + debug_assert (!mutex.try_lock ()); + nano::election_status status_l = status; status_l.confirmation_request_count = confirmation_request_count; status_l.block_count = nano::narrow_cast (last_blocks.size ()); status_l.voter_count = nano::narrow_cast (last_votes.size ()); - return nano::election_extended_status{ status_l, last_votes, tally_impl () }; + return nano::election_extended_status{ status_l, last_votes, last_blocks, tally_impl () }; } std::shared_ptr nano::election::winner () const @@ -540,18 +571,31 @@ void nano::election::broadcast_vote_locked (nano::unique_lock & loc return; } last_vote = std::chrono::steady_clock::now (); + if (node.config.enable_voting && node.wallets.reps ().voting > 0) { - node.stats.inc (nano::stat::type::election, nano::stat::detail::generate_vote); + node.stats.inc (nano::stat::type::election, nano::stat::detail::broadcast_vote); if (confirmed_locked () || have_quorum (tally_impl ())) { - node.stats.inc (nano::stat::type::election, nano::stat::detail::generate_vote_final); + node.stats.inc (nano::stat::type::election, nano::stat::detail::broadcast_vote_final); + node.logger.trace (nano::log::type::election, nano::log::detail::broadcast_vote, + nano::log::arg{ "id", id }, + nano::log::arg{ "qualified_root", qualified_root }, + nano::log::arg{ "winner", status.winner }, + nano::log::arg{ "type", "final" }); + node.final_generator.add (root, status.winner->hash ()); // Broadcasts vote to the network } else { - node.stats.inc (nano::stat::type::election, nano::stat::detail::generate_vote_normal); + node.stats.inc (nano::stat::type::election, nano::stat::detail::broadcast_vote_normal); + node.logger.trace (nano::log::type::election, nano::log::detail::broadcast_vote, + nano::log::arg{ "id", id }, + nano::log::arg{ "qualified_root", qualified_root }, + nano::log::arg{ "winner", status.winner }, + nano::log::arg{ "type", "normal" }); + node.generator.add (root, status.winner->hash ()); // Broadcasts vote to the network } } @@ -701,3 +745,44 @@ nano::election_behavior nano::election::behavior () const { return behavior_m; } + +// TODO: Remove the need for .to_string () calls +void nano::election::operator() (nano::object_stream & obs) const +{ + obs.write ("id", id); + obs.write ("qualified_root", qualified_root.to_string ()); + obs.write ("behaviour", behavior_m); + obs.write ("height", height); + obs.write ("status", current_status ()); +} + +void nano::election_extended_status::operator() (nano::object_stream & obs) const +{ + obs.write ("winner", status.winner->hash ().to_string ()); + obs.write ("tally_amount", status.tally.to_string_dec ()); + obs.write ("final_tally_amount", status.final_tally.to_string_dec ()); + obs.write ("confirmation_request_count", status.confirmation_request_count); + obs.write ("block_count", status.block_count); + obs.write ("voter_count", status.voter_count); + obs.write ("type", status.type); + + obs.write_range ("votes", votes, [] (auto const & entry, nano::object_stream & obs) { + auto & [account, info] = entry; + obs.write ("account", account.to_account ()); + obs.write ("hash", info.hash.to_string ()); + obs.write ("final", nano::vote::is_final_timestamp (info.timestamp)); + obs.write ("timestamp", info.timestamp); + obs.write ("time", info.time.time_since_epoch ().count ()); + }); + + obs.write_range ("blocks", blocks, [] (auto const & entry) { + auto [hash, block] = entry; + return block; + }); + + obs.write_range ("tally", tally, [] (auto const & entry, nano::object_stream & obs) { + auto & [amount, block] = entry; + obs.write ("hash", block->hash ().to_string ()); + obs.write ("amount", amount); + }); +} \ No newline at end of file diff --git a/nano/node/election.hpp b/nano/node/election.hpp index b9561fc68a..48f695c2fe 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -70,7 +71,10 @@ struct election_extended_status final { nano::election_status status; std::unordered_map votes; + std::unordered_map> blocks; nano::tally_t tally; + + void operator() (nano::object_stream &) const; }; class election final : public std::enable_shared_from_this @@ -169,6 +173,7 @@ class election final : public std::enable_shared_from_this private: nano::tally_t tally_impl () const; bool confirmed_locked () const; + nano::election_extended_status current_status_locked () const; // lock_a does not own the mutex on return void confirm_once (nano::unique_lock & lock_a, nano::election_status_type = nano::election_status_type::active_confirmed_quorum); void broadcast_block (nano::confirmation_solicitor &); @@ -203,6 +208,9 @@ class election final : public std::enable_shared_from_this mutable nano::mutex mutex; +public: // Logging + void operator() (nano::object_stream &) const; + private: // Constants static std::size_t constexpr max_blocks{ 10 }; diff --git a/nano/node/messages.cpp b/nano/node/messages.cpp index b27e26c151..b4a19784fe 100644 --- a/nano/node/messages.cpp +++ b/nano/node/messages.cpp @@ -19,6 +19,8 @@ #include #include #include +#include +#include #include #include #include @@ -82,25 +84,6 @@ bool nano::message_header::deserialize (nano::stream & stream_a) return error; } -std::string nano::message_header::to_string () const -{ - // Cast to uint16_t to get integer value since uint8_t is treated as an unsigned char in string formatting. - uint16_t type_l = static_cast (type); - uint16_t version_max_l = static_cast (version_max); - uint16_t version_using_l = static_cast (version_using); - uint16_t version_min_l = static_cast (version_min); - auto type_text = nano::to_string (type); - - std::stringstream stream; - - stream << boost::format ("NetID: %1%(%2%), ") % nano::to_string_hex (static_cast (network)) % nano::to_string (network); - stream << boost::format ("VerMaxUsingMin: %1%/%2%/%3%, ") % version_max_l % version_using_l % version_min_l; - stream << boost::format ("MsgType: %1%(%2%), ") % type_l % type_text; - stream << boost::format ("Extensions: %1%") % nano::to_string_hex (static_cast (extensions.to_ulong ())); - - return stream.str (); -} - nano::block_type nano::message_header::block_type () const { return static_cast (((extensions & block_type_mask) >> 8).to_ullong ()); @@ -316,6 +299,17 @@ bool nano::message_header::is_valid_message_type () const } } +void nano::message_header::operator() (nano::object_stream & obs) const +{ + obs.write ("type", type); + obs.write ("network", to_string (network)); + obs.write ("network_raw", static_cast (network)); + obs.write ("version", static_cast (version_using)); + obs.write ("version_min", static_cast (version_min)); + obs.write ("version_max", static_cast (version_max)); + obs.write ("extensions", static_cast (extensions.to_ulong ())); +} + /* * message */ @@ -348,6 +342,11 @@ nano::message_type nano::message::type () const return header.type; } +void nano::message::operator() (nano::object_stream & obs) const +{ + obs.write ("header", header); +} + /* * keepalive */ @@ -413,19 +412,11 @@ bool nano::keepalive::operator== (nano::keepalive const & other_a) const return peers == other_a.peers; } -std::string nano::keepalive::to_string () const +void nano::keepalive::operator() (nano::object_stream & obs) const { - std::stringstream stream; + nano::message::operator() (obs); // Write common data - stream << header.to_string (); - - for (auto peer = peers.begin (); peer != peers.end (); ++peer) - { - stream << "\n" - << peer->address ().to_string () + ":" + std::to_string (peer->port ()); - } - - return stream.str (); + obs.write_range ("peers", peers); } /* @@ -474,9 +465,11 @@ bool nano::publish::operator== (nano::publish const & other_a) const return *block == *other_a.block; } -std::string nano::publish::to_string () const +void nano::publish::operator() (nano::object_stream & obs) const { - return header.to_string () + "\n" + block->to_json (); + nano::message::operator() (obs); // Write common data + + obs.write ("block", block); } /* @@ -579,19 +572,6 @@ bool nano::confirm_req::operator== (nano::confirm_req const & other_a) const return equal; } -std::string nano::confirm_req::roots_string () const -{ - std::string result; - for (auto & root_hash : roots_hashes) - { - result += root_hash.first.to_string (); - result += ":"; - result += root_hash.second.to_string (); - result += ", "; - } - return result; -} - uint8_t nano::confirm_req::hash_count (const nano::message_header & header) { if (header.confirm_is_v2 ()) @@ -610,16 +590,16 @@ std::size_t nano::confirm_req::size (nano::message_header const & header) return count * (sizeof (decltype (roots_hashes)::value_type::first) + sizeof (decltype (roots_hashes)::value_type::second)); } -std::string nano::confirm_req::to_string () const +void nano::confirm_req::operator() (nano::object_stream & obs) const { - std::string s = header.to_string (); + nano::message::operator() (obs); // Write common data - for (auto && roots_hash : roots_hashes) - { - s += "\n" + roots_hash.first.to_string () + ":" + roots_hash.second.to_string (); - } - - return s; + // Write roots as: [ { root: ##, hash: ## } ,...] + obs.write_range ("roots", roots_hashes, [] (auto const & root_hash, nano::object_stream & obs) { + auto [root, hash] = root_hash; + obs.write ("root", root); + obs.write ("hash", hash); + }); } /* @@ -691,9 +671,11 @@ std::size_t nano::confirm_ack::size (const nano::message_header & header) return nano::vote::size (count); } -std::string nano::confirm_ack::to_string () const +void nano::confirm_ack::operator() (nano::object_stream & obs) const { - return header.to_string () + "\n" + vote->to_json (); + nano::message::operator() (obs); // Write common data + + obs.write ("vote", vote); } /* @@ -750,13 +732,13 @@ bool nano::frontier_req::operator== (nano::frontier_req const & other_a) const return start == other_a.start && age == other_a.age && count == other_a.count; } -std::string nano::frontier_req::to_string () const +void nano::frontier_req::operator() (nano::object_stream & obs) const { - std::string s = header.to_string (); - s += "\nstart=" + start.to_string (); - s += " maxage=" + std::to_string (age); - s += " count=" + std::to_string (count); - return s; + nano::message::operator() (obs); // Write common data + + obs.write ("start", start); + obs.write ("age", age); + obs.write ("count", count); } /* @@ -859,13 +841,13 @@ void nano::bulk_pull::set_count_present (bool value_a) header.extensions.set (count_present_flag, value_a); } -std::string nano::bulk_pull::to_string () const +void nano::bulk_pull::operator() (nano::object_stream & obs) const { - std::string s = header.to_string (); - s += "\nstart=" + start.to_string (); - s += " end=" + end.to_string (); - s += " cnt=" + std::to_string (count); - return s; + nano::message::operator() (obs); // Write common data + + obs.write ("start", start); + obs.write ("end", end); + obs.write ("count", count); } /* @@ -917,27 +899,13 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a) return error; } -std::string nano::bulk_pull_account::to_string () const +void nano::bulk_pull_account::operator() (nano::object_stream & obs) const { - std::string s = header.to_string () + "\n"; - s += "acc=" + account.to_string (); - s += " min=" + minimum_amount.to_string (); - switch (flags) - { - case bulk_pull_account_flags::pending_hash_and_amount: - s += " pending_hash_and_amount"; - break; - case bulk_pull_account_flags::pending_address_only: - s += " pending_address_only"; - break; - case bulk_pull_account_flags::pending_hash_amount_and_address: - s += " pending_hash_amount_and_address"; - break; - default: - s += " unknown flags"; - break; - } - return s; + nano::message::operator() (obs); // Write common data + + obs.write ("account", account); + obs.write ("minimum_amount", minimum_amount); + obs.write ("flags", static_cast (flags)); // TODO: Prettier flag printing } /* @@ -970,6 +938,11 @@ void nano::bulk_push::visit (nano::message_visitor & visitor_a) const visitor_a.bulk_push (*this); } +void nano::bulk_push::operator() (nano::object_stream & obs) const +{ + nano::message::operator() (obs); // Write common data +} + /* * telemetry_req */ @@ -1000,9 +973,9 @@ void nano::telemetry_req::visit (nano::message_visitor & visitor_a) const visitor_a.telemetry_req (*this); } -std::string nano::telemetry_req::to_string () const +void nano::telemetry_req::operator() (nano::object_stream & obs) const { - return header.to_string (); + nano::message::operator() (obs); // Write common data } /* @@ -1080,18 +1053,14 @@ bool nano::telemetry_ack::is_empty_payload () const return size () == 0; } -std::string nano::telemetry_ack::to_string () const +void nano::telemetry_ack::operator() (nano::object_stream & obs) const { - std::string s = header.to_string () + "\n"; - if (is_empty_payload ()) - { - s += "empty telemetry payload"; - } - else + nano::message::operator() (obs); // Write common data + + if (!is_empty_payload ()) { - s += data.to_string (); + obs.write ("data", data); } - return s; } /* @@ -1247,15 +1216,6 @@ nano::error nano::telemetry_data::deserialize_json (nano::jsonconfig & json, boo return json.get_error (); } -std::string nano::telemetry_data::to_string () const -{ - nano::jsonconfig jc; - serialize_json (jc, true); - std::stringstream ss; - jc.write (ss); - return ss.str (); -} - bool nano::telemetry_data::operator== (nano::telemetry_data const & data_a) const { return (signature == data_a.signature && node_id == data_a.node_id && 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 && active_difficulty == data_a.active_difficulty && unknown_data == data_a.unknown_data); @@ -1289,6 +1249,11 @@ bool nano::telemetry_data::validate_signature () const return nano::validate_message (node_id, bytes.data (), bytes.size (), signature); } +void nano::telemetry_data::operator() (nano::object_stream & obs) const +{ + // TODO: Telemetry data +} + /* * node_id_handshake */ @@ -1406,19 +1371,12 @@ std::size_t nano::node_id_handshake::size (nano::message_header const & header) return result; } -std::string nano::node_id_handshake::to_string () const +void nano::node_id_handshake::operator() (nano::object_stream & obs) const { - std::string s = header.to_string (); - if (query) - { - s += "\ncookie=" + query->cookie.to_string (); - } - if (response) - { - s += "\nresp_node_id=" + response->node_id.to_string (); - s += "\nresp_sig=" + response->signature.to_string (); - } - return s; + nano::message::operator() (obs); // Write common data + + obs.write ("query", query); + obs.write ("response", response); } /* @@ -1435,6 +1393,11 @@ void nano::node_id_handshake::query_payload::deserialize (nano::stream & stream) nano::read (stream, cookie); } +void nano::node_id_handshake::query_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("cookie", cookie); +} + /* * node_id_handshake::response_payload */ @@ -1518,6 +1481,19 @@ bool nano::node_id_handshake::response_payload::validate (const nano::uint256_un return true; // OK } +void nano::node_id_handshake::response_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("node_id", node_id); + obs.write ("signature", signature); + + obs.write ("v2", v2.has_value ()); + if (v2) + { + obs.write ("salt", v2->salt); + obs.write ("genesis", v2->genesis); + } +} + /* * asc_pull_req */ @@ -1648,35 +1624,16 @@ bool nano::asc_pull_req::verify_consistency () const return true; // Just for convenience of calling from asserts } -std::string nano::asc_pull_req::to_string () const +void nano::asc_pull_req::operator() (nano::object_stream & obs) const { - std::string s = header.to_string () + "\n"; - - std::visit ([&s] (auto && arg) { - using T = std::decay_t; - - if constexpr (std::is_same_v) - { - s += "missing payload"; - } + nano::message::operator() (obs); // Write common data - else if constexpr (std::is_same_v) - { - s += "acc:" + arg.start.to_string (); - s += " max block count:" + to_string_hex (static_cast (arg.count)); - s += " hash type:" + to_string_hex (static_cast (arg.start_type)); - } - - else if constexpr (std::is_same_v) - { - s += "target:" + arg.target.to_string (); - s += " hash type:" + to_string_hex (static_cast (arg.target_type)); - } - }, - payload); + obs.write ("type", type); + obs.write ("id", id); - return s; + std::visit ([&obs] (auto && pld) { pld (obs); }, payload); // Log payload } + /* * asc_pull_req::blocks_payload */ @@ -1695,6 +1652,13 @@ void nano::asc_pull_req::blocks_payload::deserialize (nano::stream & stream) nano::read (stream, start_type); } +void nano::asc_pull_req::blocks_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("start", start); + obs.write ("start_type", start_type); + obs.write ("count", count); +} + /* * asc_pull_req::account_info_payload */ @@ -1711,6 +1675,12 @@ void nano::asc_pull_req::account_info_payload::deserialize (stream & stream) nano::read (stream, target_type); } +void nano::asc_pull_req::account_info_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("target", target); + obs.write ("target_type", target_type); +} + /* * asc_pull_req::frontiers_payload */ @@ -1727,6 +1697,12 @@ void nano::asc_pull_req::frontiers_payload::deserialize (nano::stream & stream) nano::read_big_endian (stream, count); } +void nano::asc_pull_req::frontiers_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("start", start); + obs.write ("count", count); +} + /* * asc_pull_ack */ @@ -1858,43 +1834,14 @@ bool nano::asc_pull_ack::verify_consistency () const return true; // Just for convenience of calling from asserts } -std::string nano::asc_pull_ack::to_string () const +void nano::asc_pull_ack::operator() (nano::object_stream & obs) const { - std::string s = header.to_string () + "\n"; - - std::visit ([&s] (auto && arg) { - using T = std::decay_t; - - if constexpr (std::is_same_v) - { - s += "missing payload"; - } + nano::message::operator() (obs); // Write common data - else if constexpr (std::is_same_v) - { - auto block = std::begin (arg.blocks); - auto end_block = std::end (arg.blocks); - - while (block != end_block) - { - s += (*block)->to_json (); - ++block; - } - } - - else if constexpr (std::is_same_v) - { - s += "account public key:" + arg.account.to_account (); - s += " account open:" + arg.account_open.to_string (); - s += " account head:" + arg.account_head.to_string (); - s += " block count:" + to_string_hex (arg.account_block_count); - s += " confirmation frontier:" + arg.account_conf_frontier.to_string (); - s += " confirmation height:" + to_string_hex (arg.account_conf_height); - } - }, - payload); + obs.write ("type", type); + obs.write ("id", id); - return s; + std::visit ([&obs] (auto && pld) { pld (obs); }, payload); // Log payload } /* @@ -1924,6 +1871,11 @@ void nano::asc_pull_ack::blocks_payload::deserialize (nano::stream & stream) } } +void nano::asc_pull_ack::blocks_payload::operator() (nano::object_stream & obs) const +{ + obs.write_range ("blocks", blocks); +} + /* * asc_pull_ack::account_info_payload */ @@ -1948,6 +1900,16 @@ void nano::asc_pull_ack::account_info_payload::deserialize (nano::stream & strea nano::read_big_endian (stream, account_conf_height); } +void nano::asc_pull_ack::account_info_payload::operator() (nano::object_stream & obs) const +{ + obs.write ("account", account); + obs.write ("open", account_open); + obs.write ("head", account_head); + obs.write ("block_count", account_block_count); + obs.write ("conf_frontier", account_conf_frontier); + obs.write ("conf_height", account_conf_height); +} + /* * asc_pull_ack::frontiers_payload */ @@ -1989,6 +1951,15 @@ void nano::asc_pull_ack::frontiers_payload::deserialize (nano::stream & stream) } } +void nano::asc_pull_ack::frontiers_payload::operator() (nano::object_stream & obs) const +{ + obs.write_range ("frontiers", frontiers, [] (auto const & entry, nano::object_stream & obs) { + auto & [account, hash] = entry; + obs.write ("account", account); + obs.write ("hash", hash); + }); +} + /* * */ @@ -2004,3 +1975,10 @@ nano::stat::detail nano::to_stat_detail (nano::message_type type) debug_assert (value); return value.value_or (nano::stat::detail{}); } + +nano::log::detail nano::to_log_detail (nano::message_type type) +{ + auto value = magic_enum::enum_cast (magic_enum::enum_name (type)); + debug_assert (value); + return value.value_or (nano::log::detail{}); +} diff --git a/nano/node/messages.hpp b/nano/node/messages.hpp index d662054bdb..68d5d4247a 100644 --- a/nano/node/messages.hpp +++ b/nano/node/messages.hpp @@ -5,7 +5,10 @@ #include #include #include +#include +#include #include +#include #include #include #include @@ -46,6 +49,7 @@ enum class message_type : uint8_t std::string_view to_string (nano::message_type); stat::detail to_stat_detail (nano::message_type); +log::detail to_log_detail (nano::message_type); enum class bulk_pull_account_flags : uint8_t { @@ -67,8 +71,6 @@ class message_header final void serialize (nano::stream &) const; bool deserialize (nano::stream &); - std::string to_string () const; - public: // Payload nano::networks network; uint8_t version_max; @@ -112,6 +114,9 @@ class message_header final static extensions_bitset_t constexpr count_v2_mask_left{ 0xf000 }; static extensions_bitset_t constexpr count_v2_mask_right{ 0x00f0 }; static extensions_bitset_t constexpr telemetry_size_mask{ 0x3ff }; + +public: // Logging + void operator() (nano::object_stream &) const; }; class message @@ -130,6 +135,9 @@ class message public: nano::message_header header; + +public: // Logging + virtual void operator() (nano::object_stream &) const; }; class keepalive final : public message @@ -143,7 +151,9 @@ class keepalive final : public message bool operator== (nano::keepalive const &) const; std::array peers; static std::size_t constexpr size = 8 * (16 + 2); - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class publish final : public message @@ -157,7 +167,9 @@ class publish final : public message bool operator== (nano::publish const &) const; std::shared_ptr block; nano::uint128_t digest{ 0 }; - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class confirm_req final : public message @@ -172,7 +184,6 @@ class confirm_req final : public message void visit (nano::message_visitor &) const override; bool operator== (nano::confirm_req const &) const; std::string roots_string () const; - std::string to_string () const; static std::size_t size (nano::message_header const &); @@ -181,6 +192,9 @@ class confirm_req final : public message public: // Payload std::vector> roots_hashes; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class confirm_ack final : public message @@ -192,7 +206,6 @@ class confirm_ack final : public message void serialize (nano::stream &) const override; void visit (nano::message_visitor &) const override; bool operator== (nano::confirm_ack const &) const; - std::string to_string () const; static std::size_t size (nano::message_header const &); @@ -201,6 +214,9 @@ class confirm_ack final : public message public: // Payload std::shared_ptr vote; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class frontier_req final : public message @@ -216,7 +232,9 @@ class frontier_req final : public message uint32_t age; uint32_t count; static std::size_t constexpr size = sizeof (start) + sizeof (age) + sizeof (count); - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; enum class telemetry_maker : uint8_t @@ -256,13 +274,16 @@ class telemetry_data bool validate_signature () const; bool operator== (nano::telemetry_data const &) const; bool operator!= (nano::telemetry_data const &) const; - std::string to_string () const; // Size does not include unknown_data static auto constexpr size = sizeof (signature) + sizeof (node_id) + 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) + sizeof (minor_version) + sizeof (patch_version) + sizeof (pre_release_version) + sizeof (maker) + sizeof (uint64_t) + sizeof (active_difficulty); static auto constexpr latest_size = size; // This needs to be updated for each new telemetry version + private: void serialize_without_signature (nano::stream &) const; + +public: // Logging + void operator() (nano::object_stream &) const; }; class telemetry_req final : public message @@ -273,7 +294,9 @@ class telemetry_req final : public message void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void visit (nano::message_visitor &) const override; - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class telemetry_ack final : public message @@ -287,9 +310,11 @@ class telemetry_ack final : public message bool deserialize (nano::stream &); uint16_t size () const; bool is_empty_payload () const; - std::string to_string () const; static uint16_t size (nano::message_header const &); nano::telemetry_data data; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class bulk_pull final : public message @@ -309,7 +334,9 @@ class bulk_pull final : public message static std::size_t constexpr count_present_flag = nano::message_header::bulk_pull_count_present_flag; static std::size_t constexpr extended_parameters_size = 8; static std::size_t constexpr size = sizeof (start) + sizeof (end); - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class bulk_pull_account final : public message @@ -324,7 +351,9 @@ class bulk_pull_account final : public message nano::amount minimum_amount; bulk_pull_account_flags flags; static std::size_t constexpr size = sizeof (account) + sizeof (minimum_amount) + sizeof (bulk_pull_account_flags); - std::string to_string () const; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class bulk_push final : public message @@ -335,6 +364,9 @@ class bulk_push final : public message void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void visit (nano::message_visitor &) const override; + +public: // Logging + void operator() (nano::object_stream &) const override; }; class node_id_handshake final : public message @@ -350,6 +382,9 @@ class node_id_handshake final : public message public: nano::uint256_union cookie; + + public: // Logging + void operator() (nano::object_stream &) const; }; class response_payload @@ -380,6 +415,9 @@ class node_id_handshake final : public message static std::size_t constexpr size_v1 = sizeof (nano::account) + sizeof (nano::signature); static std::size_t constexpr size_v2 = sizeof (nano::account) + sizeof (nano::signature) + sizeof (v2_payload); static std::size_t size (nano::message_header const &); + + public: // Logging + void operator() (nano::object_stream &) const; }; public: @@ -392,7 +430,6 @@ class node_id_handshake final : public message void visit (nano::message_visitor &) const override; std::size_t size () const; static std::size_t size (nano::message_header const &); - std::string to_string () const; public: // Header static uint8_t constexpr query_flag = 0; @@ -407,6 +444,9 @@ class node_id_handshake final : public message public: // Payload std::optional query; std::optional response; + +public: // Logging + void operator() (nano::object_stream &) const override; }; /** @@ -432,6 +472,10 @@ struct empty_payload { debug_assert (false); } + void operator() (nano::object_stream &) const + { + debug_assert (false); + } }; /** @@ -459,7 +503,6 @@ class asc_pull_req final : public message void serialize_payload (nano::stream &) const; void deserialize_payload (nano::stream &); - std::string to_string () const; private: // Debug /** @@ -479,10 +522,13 @@ class asc_pull_req final : public message void serialize (nano::stream &) const; void deserialize (nano::stream &); - // Payload + public: // Payload nano::hash_or_account start{ 0 }; uint8_t count{ 0 }; hash_type start_type{}; + + public: // Logging + void operator() (nano::object_stream &) const; }; struct account_info_payload @@ -490,9 +536,12 @@ class asc_pull_req final : public message void serialize (nano::stream &) const; void deserialize (nano::stream &); - // Payload + public: // Payload nano::hash_or_account target{ 0 }; hash_type target_type{}; + + public: // Logging + void operator() (nano::object_stream &) const; }; struct frontiers_payload @@ -500,9 +549,12 @@ class asc_pull_req final : public message void serialize (nano::stream &) const; void deserialize (nano::stream &); - // Payload + public: // Payload nano::account start{ 0 }; uint16_t count{ 0 }; + + public: // Logging + void operator() (nano::object_stream &) const; }; public: // Payload @@ -515,6 +567,9 @@ class asc_pull_req final : public message public: /** Size of message without payload */ constexpr static std::size_t partial_size = sizeof (type) + sizeof (id); + +public: // Logging + void operator() (nano::object_stream &) const override; }; /** @@ -542,7 +597,6 @@ class asc_pull_ack final : public message void serialize_payload (nano::stream &) const; void deserialize_payload (nano::stream &); - std::string to_string () const; private: // Debug /** @@ -559,8 +613,11 @@ class asc_pull_ack final : public message void serialize (nano::stream &) const; void deserialize (nano::stream &); - // Payload + public: // Payload std::vector> blocks; + + public: // Logging + void operator() (nano::object_stream &) const; }; struct account_info_payload @@ -568,13 +625,16 @@ class asc_pull_ack final : public message void serialize (nano::stream &) const; void deserialize (nano::stream &); - // Payload + public: // Payload nano::account account{ 0 }; nano::block_hash account_open{ 0 }; nano::block_hash account_head{ 0 }; uint64_t account_block_count{ 0 }; nano::block_hash account_conf_frontier{ 0 }; uint64_t account_conf_height{ 0 }; + + public: // Logging + void operator() (nano::object_stream &) const; }; struct frontiers_payload @@ -590,8 +650,11 @@ class asc_pull_ack final : public message static void serialize_frontier (nano::stream &, frontier const &); static frontier deserialize_frontier (nano::stream &); - // Payload + public: // Payload std::vector frontiers; + + public: // Logging + void operator() (nano::object_stream &) const; }; public: // Payload @@ -604,6 +667,9 @@ class asc_pull_ack final : public message public: /** Size of message without payload */ constexpr static std::size_t partial_size = sizeof (type) + sizeof (id); + +public: // Logging + void operator() (nano::object_stream &) const override; }; class message_visitor diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 9f33370cc1..cc41cd3c3d 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -468,7 +468,8 @@ class network_message_visitor : public nano::message_visitor void nano::network::process_message (nano::message const & message, std::shared_ptr const & channel) { - node.stats.inc (nano::stat::type::message, to_stat_detail (message.header.type), nano::stat::dir::in); + node.stats.inc (nano::stat::type::message, to_stat_detail (message.type ()), nano::stat::dir::in); + node.logger.trace (nano::log::type::network_processed, to_log_detail (message.type ()), nano::log::arg{ "message", message }); network_message_visitor visitor{ node, channel }; message.visit (visitor); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index cb854c326f..24a2e31158 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -185,8 +185,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons vote_uniquer{}, confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, logger, node_initialized_latch, flags.confirmation_height_processor_mode), vote_cache{ config.vote_cache, stats }, - generator{ config, ledger, wallets, vote_processor, history, network, stats, /* non-final */ false }, - final_generator{ config, ledger, wallets, vote_processor, history, network, stats, /* final */ true }, + generator{ config, ledger, wallets, vote_processor, history, network, stats, logger, /* non-final */ false }, + final_generator{ config, ledger, wallets, vote_processor, history, network, stats, logger, /* final */ true }, active (*this, confirmation_height_processor), scheduler_impl{ std::make_unique (*this) }, scheduler{ *scheduler_impl }, @@ -1298,6 +1298,8 @@ void nano::node::process_confirmed (nano::election_status const & status_a, uint decltype (iteration_a) const num_iters = (config.block_processor_batch_max_time / network_params.node.process_confirmed_interval) * 4; if (auto block_l = ledger.store.block.get (ledger.store.tx_begin_read (), hash)) { + logger.trace (nano::log::type::node, nano::log::detail::process_confirmed, nano::log::arg{ "block", block_l }); + confirmation_height_processor.add (block_l); } else if (iteration_a < num_iters) diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index c75c5b0976..8232a4b653 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -51,12 +51,21 @@ bool nano::scheduler::priority::activate (nano::account const & account_a, store debug_assert (block != nullptr); if (node.ledger.dependents_confirmed (transaction, *block)) { - stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::activated); - auto balance = node.ledger.balance (transaction, hash); - auto previous_balance = node.ledger.balance (transaction, conf_info.frontier); + auto const balance = node.ledger.balance (transaction, hash); + auto const previous_balance = node.ledger.balance (transaction, conf_info.frontier); + auto const balance_priority = std::max (balance, previous_balance); + + node.stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::activated); + node.logger.trace (nano::log::type::election_scheduler, nano::log::detail::block_activated, + nano::log::arg{ "account", account_a.to_account () }, // TODO: Convert to lazy eval + nano::log::arg{ "block", block }, + nano::log::arg{ "time", info->modified }, + nano::log::arg{ "priority", balance_priority }); + nano::lock_guard lock{ mutex }; - buckets->push (info->modified, block, std::max (balance, previous_balance)); + buckets->push (info->modified, block, balance_priority); notify (); + return true; // Activated } } diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 99581f4712..9be0940f13 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -23,12 +23,20 @@ void nano::transport::channel::send (nano::message & message_a, std::function +#include #include #include #include @@ -140,6 +141,9 @@ class channel protected: nano::node & node; + +public: // Logging + virtual void operator() (nano::object_stream &) const; }; } diff --git a/nano/node/transport/socket.cpp b/nano/node/transport/socket.cpp index 609bb75220..4271905534 100644 --- a/nano/node/transport/socket.cpp +++ b/nano/node/transport/socket.cpp @@ -13,6 +13,8 @@ #include #include +#include + /* * socket */ @@ -351,6 +353,14 @@ nano::tcp_endpoint nano::transport::socket::local_endpoint () const return local; } +void nano::transport::socket::operator() (nano::object_stream & obs) const +{ + obs.write ("remote_endpoint", remote_endpoint ()); + obs.write ("local_endpoint", local_endpoint ()); + obs.write ("type", type_m); + obs.write ("endpoint_type", endpoint_type_m); +} + /* * write_queue */ @@ -458,18 +468,7 @@ std::size_t network_prefix) return counted_connections; } -std::string nano::transport::socket_type_to_string (nano::transport::socket::type_t type) +std::string_view nano::transport::to_string (nano::transport::socket::type_t type) { - switch (type) - { - case nano::transport::socket::type_t::undefined: - return "undefined"; - case nano::transport::socket::type_t::bootstrap: - return "bootstrap"; - case nano::transport::socket::type_t::realtime: - return "realtime"; - case nano::transport::socket::type_t::realtime_response_server: - return "realtime_response_server"; - } - return "n/a"; + return magic_enum::enum_name (type); } diff --git a/nano/node/transport/socket.hpp b/nano/node/transport/socket.hpp index 0ac01400fc..91f7d008fc 100644 --- a/nano/node/transport/socket.hpp +++ b/nano/node/transport/socket.hpp @@ -207,9 +207,12 @@ class socket final : public std::enable_shared_from_this>; diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 25fd21a5ba..c9a6c19dd2 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -112,6 +112,13 @@ void nano::transport::channel_tcp::set_endpoint () } } +void nano::transport::channel_tcp::operator() (nano::object_stream & obs) const +{ + nano::transport::channel::operator() (obs); // Write common data + + obs.write ("socket", socket); +} + /* * tcp_channels */ diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index 80196a3089..7b6efd9420 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -93,7 +93,11 @@ namespace transport private: nano::tcp_endpoint endpoint{ boost::asio::ip::address_v6::any (), 0 }; + + public: // Logging + void operator() (nano::object_stream &) const override; }; + class tcp_channels final { friend class nano::transport::channel_tcp; diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 0885da8332..524dbdc8ee 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -174,6 +174,10 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr break; } + logger.trace (nano::log::type::vote_processor, nano::log::detail::vote_processed, + nano::log::arg{ "vote", vote_a }, + nano::log::arg{ "result", result }); + return result; } diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index 401ebe8327..b238f38538 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -161,7 +161,7 @@ std::unique_ptr nano::collect_container_info (na return composite; } -nano::vote_generator::vote_generator (nano::node_config const & config_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::vote_processor & vote_processor_a, nano::local_vote_history & history_a, nano::network & network_a, nano::stats & stats_a, bool is_final_a) : +nano::vote_generator::vote_generator (nano::node_config const & config_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::vote_processor & vote_processor_a, nano::local_vote_history & history_a, nano::network & network_a, nano::stats & stats_a, nano::logger & logger_a, bool is_final_a) : config (config_a), ledger (ledger_a), wallets (wallets_a), @@ -170,6 +170,7 @@ nano::vote_generator::vote_generator (nano::node_config const & config_a, nano:: spacing{ config_a.network_params.voting.delay }, network (network_a), stats (stats_a), + logger (logger_a), is_final (is_final_a), vote_generation_queue{ stats, nano::stat::type::vote_generator, nano::thread_role::name::vote_generator_queue, /* single threaded */ 1, /* max queue size */ 1024 * 32, /* max batch size */ 1024 * 4 } { @@ -185,18 +186,23 @@ nano::vote_generator::~vote_generator () bool nano::vote_generator::should_vote (store::write_transaction const & transaction, nano::root const & root_a, nano::block_hash const & hash_a) { + auto block = ledger.store.block.get (transaction, hash_a); bool should_vote = false; if (is_final) { - auto block (ledger.store.block.get (transaction, hash_a)); should_vote = block != nullptr && ledger.dependents_confirmed (transaction, *block) && ledger.store.final_vote.put (transaction, block->qualified_root (), hash_a); debug_assert (block == nullptr || root_a == block->root ()); } else { - auto block (ledger.store.block.get (transaction, hash_a)); should_vote = block != nullptr && ledger.dependents_confirmed (transaction, *block); } + + logger.trace (nano::log::type::vote_generator, nano::log::detail::should_vote, + nano::log::arg{ "should_vote", should_vote }, + nano::log::arg{ "block", block }, + nano::log::arg{ "is_final", is_final }); + return should_vote; } diff --git a/nano/node/voting.hpp b/nano/node/voting.hpp index def5f78a56..6a2b2c79b6 100644 --- a/nano/node/voting.hpp +++ b/nano/node/voting.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include @@ -121,7 +122,7 @@ class vote_generator final using queue_entry_t = std::pair; public: - vote_generator (nano::node_config const & config_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::vote_processor & vote_processor_a, nano::local_vote_history & history_a, nano::network & network_a, nano::stats & stats_a, bool is_final_a); + vote_generator (nano::node_config const &, nano::ledger &, nano::wallets &, nano::vote_processor &, nano::local_vote_history &, nano::network &, nano::stats &, nano::logger &, bool is_final); ~vote_generator (); /** Queue items for vote generation, or broadcast votes already in cache */ @@ -159,6 +160,7 @@ class vote_generator final nano::vote_spacing spacing; nano::network & network; nano::stats & stats; + nano::logger & logger; private: processing_queue vote_generation_queue; diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index b14323edf5..503d4d1271 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/secure/vote.cpp b/nano/secure/vote.cpp index 9ffeabe04a..28002f25f0 100644 --- a/nano/secure/vote.cpp +++ b/nano/secure/vote.cpp @@ -180,4 +180,12 @@ uint64_t nano::vote::packed_timestamp (uint64_t timestamp, uint8_t duration) bool nano::vote::is_final_timestamp (uint64_t timestamp) { return timestamp == std::numeric_limits::max (); +} + +void nano::vote::operator() (nano::object_stream & obs) const +{ + obs.write ("account", account); + obs.write ("final", is_final_timestamp (timestamp_m)); + obs.write ("timestamp", timestamp_m); + obs.write_range ("hashes", hashes); } \ No newline at end of file diff --git a/nano/secure/vote.hpp b/nano/secure/vote.hpp index d7c9b62b32..9ae7b0689f 100644 --- a/nano/secure/vote.hpp +++ b/nano/secure/vote.hpp @@ -71,6 +71,9 @@ class vote final static std::string const hash_prefix; static uint64_t packed_timestamp (uint64_t timestamp, uint8_t duration); + +public: // Logging + void operator() (nano::object_stream &) const; }; using vote_uniquer = nano::uniquer; From 7452def2e78d104812012e6ed6e293dbb27427e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 26 Jan 2024 18:55:48 +0100 Subject: [PATCH 062/190] Fix parsing logger ids --- nano/lib/logging.cpp | 18 ++++++++---------- nano/lib/utility.hpp | 14 +++++++++----- 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/nano/lib/logging.cpp b/nano/lib/logging.cpp index 7fbfb0b6e0..7f6a6bd35a 100644 --- a/nano/lib/logging.cpp +++ b/nano/lib/logging.cpp @@ -481,12 +481,12 @@ nano::log_config nano::load_log_config (nano::log_config fallback, const std::fi if (env_levels) { std::map levels; - for (auto const & env_level_str : nano::util::split (*env_levels, ',')) + for (auto const & env_level_str : nano::util::split (*env_levels, ",")) { try { // Split 'logger_name=level' into a pair of 'logger_name' and 'level' - auto arr = nano::util::split (env_level_str, '='); + auto arr = nano::util::split (env_level_str, "="); if (arr.size () != 2) { throw std::invalid_argument ("Invalid entry: " + env_level_str); @@ -579,16 +579,14 @@ std::string nano::log::to_string (nano::log::logger_id logger_id) */ nano::log::logger_id nano::log::parse_logger_id (const std::string & logger_name) { - auto pos = logger_name.find ("::"); - if (pos == std::string::npos) + auto parts = nano::util::split (logger_name, "::"); + if (parts.size () == 1) { - return { nano::log::parse_type (logger_name), nano::log::detail::all }; + return { nano::log::parse_type (parts[0]), nano::log::detail::all }; } - else + if (parts.size () == 2) { - auto logger_type = logger_name.substr (0, pos); - auto logger_detail = logger_name.substr (pos + 1); - - return { nano::log::parse_type (logger_type), nano::log::parse_detail (logger_detail) }; + return { nano::log::parse_type (parts[0]), nano::log::parse_detail (parts[1]) }; } + throw std::invalid_argument ("Invalid logger name: " + logger_name); } \ No newline at end of file diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index 97d8bd3ad5..7b2ce35cab 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -246,15 +246,19 @@ std::string join (Container const & container, std::string_view delimiter, Func return join (container.begin (), container.end (), delimiter, transform); } -inline std::vector split (const std::string & str, char delimiter) +inline std::vector split (std::string const & input, std::string_view delimiter) { - std::stringstream ss{ str }; std::vector result; - std::string item; - while (std::getline (ss, item, delimiter)) + std::size_t startPos = 0; + std::size_t delimiterPos = input.find (delimiter, startPos); + while (delimiterPos != std::string::npos) { - result.push_back (item); + std::string token = input.substr (startPos, delimiterPos - startPos); + result.push_back (token); + startPos = delimiterPos + delimiter.length (); + delimiterPos = input.find (delimiter, startPos); } + result.push_back (input.substr (startPos)); return result; } From fde4588dcb7e24038d9b68f7630668fcd34afbf7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 30 Jan 2024 18:08:08 +0100 Subject: [PATCH 063/190] Enable tracing in debug builds by default --- CMakeLists.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 408ed1880a..ee95085841 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -134,6 +134,12 @@ if(NANO_STACKTRACE_BACKTRACE) endif() option(NANO_TRACING "Enable trace logging" OFF) +# Check if the build type is Debug, and if so, enable NANO_TRACING by default +if(CMAKE_BUILD_TYPE STREQUAL "Debug") + set(NANO_TRACING + ON + CACHE BOOL "Enable trace logging" FORCE) +endif() if(NANO_TRACING) message(STATUS "Using trace logging") add_compile_definitions(NANO_TRACING) From 3805e36b5a276ba622734dffd502e0abca7acd3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 30 Jan 2024 19:29:05 +0100 Subject: [PATCH 064/190] Use spaces for indentation --- nano/core_test/object_stream.cpp | 124 +++++++++++++++---------------- nano/lib/object_stream.hpp | 2 +- 2 files changed, 63 insertions(+), 63 deletions(-) diff --git a/nano/core_test/object_stream.cpp b/nano/core_test/object_stream.cpp index 59c09db3bc..ead8bad719 100644 --- a/nano/core_test/object_stream.cpp +++ b/nano/core_test/object_stream.cpp @@ -212,10 +212,10 @@ TEST (object_stream, object_writer_basic) auto expected = trim (R"( object_field: { - field1: "value1", - field2: "value2", - field3: true, - field4: 1234 + field1: "value1", + field2: "value2", + field3: true, + field4: 1234 } )"); @@ -243,15 +243,15 @@ TEST (object_stream, object_writer_nested) auto expected = trim (R"( object_field: { - field1: "value1", - nested_object: { - nested_field1: "nested_value1", - nested_field2: false, - nested_field3: -1234 - }, - field2: "value2", - field3: true, - field4: 1234 + field1: "value1", + nested_object: { + nested_field1: "nested_value1", + nested_field2: false, + nested_field3: -1234 + }, + field2: "value2", + field3: true, + field4: 1234 } )"); @@ -269,9 +269,9 @@ TEST (object_stream, array_writer_basic) auto expected = trim (R"( array_field: [ - 0, - 1, - 2 + 0, + 1, + 2 ] )"); @@ -304,8 +304,8 @@ TEST (object_stream, object_basic) auto expected = trim (R"( test_object: { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" } )"); @@ -328,18 +328,18 @@ TEST (object_stream, array_writer_objects) auto expected = trim (R"( array_field: [ - { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" - }, - { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000001" - }, - { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000002" - } + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000002" + } ] )"); @@ -370,9 +370,9 @@ TEST (object_stream, object_array_basic) auto expected = trim (R"( test_object_array: [ - 1, - 2, - 3 + 1, + 2, + 3 ] )"); @@ -410,17 +410,17 @@ TEST (object_stream, object_nested) auto expected = trim (R"( test_object: { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000", - nested_object: { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" - }, - nested_array_object: [ - 1, - 2, - 3 - ] + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000", + nested_object: { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + nested_array_object: [ + 1, + 2, + 3 + ] } )"); @@ -455,18 +455,18 @@ TEST (object_stream, builtin_array) auto expected = trim (R"( array_field: [ - { - hash: "0000000000000000000000000000000000000000000000000000000000000001", - value: 1 - }, - { - hash: "0000000000000000000000000000000000000000000000000000000000000002", - value: 2 - }, - { - hash: "0000000000000000000000000000000000000000000000000000000000000003", - value: 3 - } + { + hash: "0000000000000000000000000000000000000000000000000000000000000001", + value: 1 + }, + { + hash: "0000000000000000000000000000000000000000000000000000000000000002", + value: 2 + }, + { + hash: "0000000000000000000000000000000000000000000000000000000000000003", + value: 3 + } ] )"); @@ -501,8 +501,8 @@ TEST (object_stream, ostream_adapter) auto expected = trim (R"( { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" } )"); @@ -518,8 +518,8 @@ TEST (object_stream, fmt_adapter) auto expected = trim (R"( { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" } )"); @@ -536,8 +536,8 @@ TEST (object_stream, to_string) auto expected = trim (R"( { - uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", - block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000000", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" } )"); diff --git a/nano/lib/object_stream.hpp b/nano/lib/object_stream.hpp index 02b20bf44b..40c638df91 100644 --- a/nano/lib/object_stream.hpp +++ b/nano/lib/object_stream.hpp @@ -37,7 +37,7 @@ struct object_stream_config std::string false_value{ "false" }; std::string null_value{ "null" }; - std::string indent{ "\t" }; + std::string indent{ " " }; std::string newline{ "\n" }; /** Number of decimal places to show for `float` and `double` */ From 4b1408fafd416df11f3139f7a833cbaf2eea40db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 5 Feb 2024 20:54:53 +0100 Subject: [PATCH 065/190] Use `nano::log::microseconds` helper --- nano/lib/logging.hpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 8a77dae27d..1415281ba9 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -32,6 +32,12 @@ using logger_id = std::pair; std::string to_string (logger_id); logger_id parse_logger_id (std::string const &); + +template +auto microseconds (std::chrono::time_point time) +{ + return std::chrono::duration_cast (time.time_since_epoch ()).count (); +} } namespace nano @@ -163,14 +169,13 @@ class logger final // Include info about precise time of the event auto now = std::chrono::high_resolution_clock::now (); - auto now_micros = std::chrono::duration_cast (now.time_since_epoch ()).count (); // TODO: Improve code indentation config auto logger = get_logger (type, detail); logger.trace ("{}", nano::streamed_args (global_tracing_config, nano::log::arg{ "event", to_string (std::make_pair (type, detail)) }, - nano::log::arg{ "time", now_micros }, + nano::log::arg{ "time", nano::log::microseconds (now) }, std::forward (args)...)); } } From ed60faf7217fca059852b840f4cf585e14ceea79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 5 Feb 2024 21:31:49 +0100 Subject: [PATCH 066/190] Better handling of debug build check --- CMakeLists.txt | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ee95085841..0123485cdf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -133,12 +133,11 @@ if(NANO_STACKTRACE_BACKTRACE) endif() endif() -option(NANO_TRACING "Enable trace logging" OFF) -# Check if the build type is Debug, and if so, enable NANO_TRACING by default +# Enable NANO_TRACING by default in Debug builds if(CMAKE_BUILD_TYPE STREQUAL "Debug") - set(NANO_TRACING - ON - CACHE BOOL "Enable trace logging" FORCE) + option(NANO_TRACING "Enable trace logging" ON) +else() + option(NANO_TRACING "Enable trace logging" OFF) endif() if(NANO_TRACING) message(STATUS "Using trace logging") From 330856a37883f5e5d4d8dcbf9657df2d2ad92e62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 6 Feb 2024 20:52:09 +0100 Subject: [PATCH 067/190] Lazy trace event formatter --- nano/lib/logging.hpp | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/nano/lib/logging.hpp b/nano/lib/logging.hpp index 1415281ba9..14e6e2fc3a 100644 --- a/nano/lib/logging.hpp +++ b/nano/lib/logging.hpp @@ -171,15 +171,27 @@ class logger final auto now = std::chrono::high_resolution_clock::now (); // TODO: Improve code indentation config - auto logger = get_logger (type, detail); + auto & logger = get_logger (type, detail); logger.trace ("{}", nano::streamed_args (global_tracing_config, - nano::log::arg{ "event", to_string (std::make_pair (type, detail)) }, + nano::log::arg{ "event", event_formatter{ type, detail } }, nano::log::arg{ "time", nano::log::microseconds (now) }, std::forward (args)...)); } } +private: + struct event_formatter final + { + nano::log::type type; + nano::log::detail detail; + + friend std::ostream & operator<< (std::ostream & os, event_formatter const & self) + { + return os << to_string (self.type) << "::" << to_string (self.detail); + } + }; + private: const std::string identifier; From 3ebb6f737b285dfdc21006c388e4c8b0376138db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 6 Feb 2024 22:54:26 +0100 Subject: [PATCH 068/190] Rework flow of `channel::send` --- nano/node/transport/channel.cpp | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 9be0940f13..26680ddc72 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -16,28 +16,24 @@ nano::transport::channel::channel (nano::node & node_a) : void nano::transport::channel::send (nano::message & message_a, std::function const & callback_a, nano::transport::buffer_drop_policy drop_policy_a, nano::transport::traffic_type traffic_type) { - auto buffer (message_a.to_shared_const_buffer ()); - auto detail = to_stat_detail (message_a.header.type); - auto is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter); - auto should_pass (node.outbound_limiter.should_pass (buffer.size (), to_bandwidth_limit_type (traffic_type))); - if (!is_droppable_by_limiter || should_pass) - { - node.stats.inc (nano::stat::type::message, detail, nano::stat::dir::out); - node.logger.trace (nano::log::type::channel_sent, nano::to_log_detail (message_a.type ()), - nano::log::arg{ "message", message_a }, - nano::log::arg{ "channel", *this }, - nano::log::arg{ "dropped", false }); + auto buffer = message_a.to_shared_const_buffer (); + + bool is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter); + bool should_pass = node.outbound_limiter.should_pass (buffer.size (), to_bandwidth_limit_type (traffic_type)); + bool pass = !is_droppable_by_limiter || should_pass; + + node.stats.inc (pass ? nano::stat::type::message : nano::stat::type::drop, to_stat_detail (message_a.type ()), nano::stat::dir::out); + node.logger.trace (nano::log::type::channel_sent, to_log_detail (message_a.type ()), + nano::log::arg{ "message", message_a }, + nano::log::arg{ "channel", *this }, + nano::log::arg{ "dropped", !pass }); + if (pass) + { send_buffer (buffer, callback_a, drop_policy_a, traffic_type); } else { - node.stats.inc (nano::stat::type::drop, detail, nano::stat::dir::out); - node.logger.trace (nano::log::type::channel_sent, nano::to_log_detail (message_a.type ()), - nano::log::arg{ "message", message_a }, - nano::log::arg{ "channel", *this }, - nano::log::arg{ "dropped", true }); - if (callback_a) { node.background ([callback_a] () { From 9332812c69d642b163fa32d5a2b6766df405de01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 15:00:09 +0100 Subject: [PATCH 069/190] Remove gap cache (#4422) * Move gap tracker logic into `gap_cache` * Remove gap cache --- nano/core_test/CMakeLists.txt | 1 - nano/core_test/gap_cache.cpp | 168 ---------------------------------- nano/core_test/node.cpp | 20 ---- nano/node/CMakeLists.txt | 4 - nano/node/blockprocessor.cpp | 1 - nano/node/gap_cache.cpp | 136 --------------------------- nano/node/gap_cache.hpp | 59 ------------ nano/node/gap_tracker.cpp | 29 ------ nano/node/gap_tracker.hpp | 24 ----- nano/node/node.cpp | 7 +- nano/node/node.hpp | 4 - 11 files changed, 1 insertion(+), 452 deletions(-) delete mode 100644 nano/core_test/gap_cache.cpp delete mode 100644 nano/node/gap_cache.cpp delete mode 100644 nano/node/gap_cache.hpp delete mode 100644 nano/node/gap_tracker.cpp delete mode 100644 nano/node/gap_tracker.hpp diff --git a/nano/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt index dda4bccab5..8f16a81f9e 100644 --- a/nano/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -22,7 +22,6 @@ add_executable( enums.cpp epochs.cpp frontiers_confirmation.cpp - gap_cache.cpp ipc.cpp ledger.cpp locks.cpp diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp deleted file mode 100644 index 561088db11..0000000000 --- a/nano/core_test/gap_cache.cpp +++ /dev/null @@ -1,168 +0,0 @@ -#include -#include -#include - -#include - -using namespace std::chrono_literals; - -TEST (gap_cache, add_new) -{ - nano::test::system system (1); - nano::gap_cache cache (*system.nodes[0]); - nano::block_builder builder; - auto block1 = builder - .send () - .previous (0) - .destination (1) - .balance (2) - .sign (nano::keypair ().prv, 4) - .work (5) - .build_shared (); - cache.add (block1->hash ()); -} - -TEST (gap_cache, add_existing) -{ - nano::test::system system (1); - nano::gap_cache cache (*system.nodes[0]); - nano::block_builder builder; - auto block1 = builder - .send () - .previous (0) - .destination (1) - .balance (2) - .sign (nano::keypair ().prv, 4) - .work (5) - .build_shared (); - cache.add (block1->hash ()); - nano::unique_lock lock{ cache.mutex }; - auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); - ASSERT_NE (cache.blocks.get<1> ().end (), existing1); - auto arrival (existing1->arrival); - lock.unlock (); - ASSERT_TIMELY (20s, arrival != std::chrono::steady_clock::now ()); - cache.add (block1->hash ()); - ASSERT_EQ (1, cache.size ()); - lock.lock (); - auto existing2 (cache.blocks.get<1> ().find (block1->hash ())); - ASSERT_NE (cache.blocks.get<1> ().end (), existing2); - ASSERT_GT (existing2->arrival, arrival); -} - -TEST (gap_cache, comparison) -{ - nano::test::system system (1); - nano::gap_cache cache (*system.nodes[0]); - nano::block_builder builder; - auto block1 = builder - .send () - .previous (1) - .destination (0) - .balance (2) - .sign (nano::keypair ().prv, 4) - .work (5) - .build_shared (); - cache.add (block1->hash ()); - nano::unique_lock lock{ cache.mutex }; - auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); - ASSERT_NE (cache.blocks.get<1> ().end (), existing1); - auto arrival (existing1->arrival); - lock.unlock (); - ASSERT_TIMELY (20s, std::chrono::steady_clock::now () != arrival); - auto block3 = builder - .send () - .previous (0) - .destination (42) - .balance (1) - .sign (nano::keypair ().prv, 3) - .work (4) - .build_shared (); - cache.add (block3->hash ()); - ASSERT_EQ (2, cache.size ()); - lock.lock (); - auto existing2 (cache.blocks.get<1> ().find (block3->hash ())); - ASSERT_NE (cache.blocks.get<1> ().end (), existing2); - ASSERT_GT (existing2->arrival, arrival); - ASSERT_EQ (arrival, cache.blocks.get<1> ().begin ()->arrival); -} - -// Upon receiving enough votes for a gapped block, a lazy bootstrap should be initiated -TEST (gap_cache, gap_bootstrap) -{ - nano::node_flags node_flags; - node_flags.disable_legacy_bootstrap = true; - node_flags.disable_request_loop = true; // to avoid fallback behavior of broadcasting blocks - nano::test::system system (2, nano::transport::transport_type::tcp, node_flags); - - auto & node1 (*system.nodes[0]); - auto & node2 (*system.nodes[1]); - nano::block_hash latest (node1.latest (nano::dev::genesis_key.pub)); - nano::keypair key; - nano::block_builder builder; - auto send = builder - .send () - .previous (latest) - .destination (key.pub) - .balance (nano::dev::constants.genesis_amount - 100) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (latest)) - .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); - ASSERT_EQ (nano::dev::constants.genesis_amount - 100, node1.balance (nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ())); - // Confirm send block, allowing voting on the upcoming block - auto election = nano::test::start_election (system, node1, send->hash ()); - ASSERT_NE (nullptr, election); - election->force_confirm (); - ASSERT_TIMELY (5s, node1.block_confirmed (send->hash ())); - node1.active.erase (*send); - system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto latest_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100)); - ASSERT_NE (nullptr, latest_block); - ASSERT_TIMELY_EQ (5s, nano::dev::constants.genesis_amount - 200, node1.balance (nano::dev::genesis->account ())); - ASSERT_TIMELY_EQ (5s, nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ())); - ASSERT_TIMELY_EQ (5s, node2.balance (nano::dev::genesis->account ()), nano::dev::constants.genesis_amount - 200); -} - -TEST (gap_cache, two_dependencies) -{ - nano::test::system system (1); - auto & node1 (*system.nodes[0]); - nano::keypair key; - nano::block_builder builder; - auto send1 = builder - .send () - .previous (nano::dev::genesis->hash ()) - .destination (key.pub) - .balance (1) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); - auto send2 = builder - .send () - .previous (send1->hash ()) - .destination (key.pub) - .balance (0) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (send1->hash ())) - .build_shared (); - auto open = builder - .open () - .source (send1->hash ()) - .representative (key.pub) - .account (key.pub) - .sign (key.prv, key.pub) - .work (*system.work.generate (key.pub)) - .build_shared (); - ASSERT_EQ (0, node1.gap_cache.size ()); - node1.block_processor.add (send2); - ASSERT_TIMELY_EQ (5s, 1, node1.gap_cache.size ()); - node1.block_processor.add (open); - ASSERT_TIMELY_EQ (5s, 2, node1.gap_cache.size ()); - node1.block_processor.add (send1); - ASSERT_TIMELY_EQ (5s, node1.gap_cache.size (), 0); - ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), send1->hash ())); - ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), send2->hash ())); - ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), open->hash ())); -} diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 996961054f..fddf1683d4 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -338,26 +338,6 @@ TEST (node, auto_bootstrap_age) node1->stop (); } -// Test ensures the block processor adds the published block to the gap cache. -TEST (node, receive_gap) -{ - nano::test::system system (1); - auto & node1 (*system.nodes[0]); - ASSERT_EQ (0, node1.gap_cache.size ()); - auto block = nano::send_block_builder () - .previous (5) - .destination (1) - .balance (2) - .sign (nano::keypair ().prv, 4) - .work (0) - .build_shared (); - node1.work_generate_blocking (*block); - nano::publish message{ nano::dev::network_params.network, block }; - auto channel1 = std::make_shared (node1); - node1.network.inbound (message, channel1); - ASSERT_TIMELY_EQ (5s, 1, node1.gap_cache.size ()); -} - TEST (node, merge_peers) { nano::test::system system (1); diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 7918388016..e340508c8f 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -26,8 +26,6 @@ add_library( block_broadcast.hpp block_publisher.cpp block_publisher.hpp - gap_tracker.cpp - gap_tracker.hpp blocking_observer.cpp blocking_observer.hpp blockprocessor.hpp @@ -88,8 +86,6 @@ add_library( election_insertion_result.hpp epoch_upgrader.hpp epoch_upgrader.cpp - gap_cache.hpp - gap_cache.cpp inactive_cache_information.hpp inactive_cache_information.cpp inactive_cache_status.hpp diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 27090889c9..c0477b4e01 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -343,7 +343,6 @@ nano::process_return nano::block_processor::process_one (store::write_transactio void nano::block_processor::queue_unchecked (store::write_transaction const & transaction_a, nano::hash_or_account const & hash_or_account_a) { node.unchecked.trigger (hash_or_account_a); - node.gap_cache.erase (hash_or_account_a.hash); } std::unique_ptr nano::collect_container_info (block_processor & block_processor, std::string const & name) diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp deleted file mode 100644 index 1ef81dd598..0000000000 --- a/nano/node/gap_cache.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include -#include - -#include - -nano::gap_cache::gap_cache (nano::node & node_a) : - node (node_a) -{ -} - -void nano::gap_cache::add (nano::block_hash const & hash_a, std::chrono::steady_clock::time_point time_point_a) -{ - nano::lock_guard lock{ mutex }; - auto existing (blocks.get ().find (hash_a)); - if (existing != blocks.get ().end ()) - { - blocks.get ().modify (existing, [time_point_a] (nano::gap_information & info) { - info.arrival = time_point_a; - }); - } - else - { - blocks.get ().emplace (nano::gap_information{ time_point_a, hash_a, std::vector () }); - if (blocks.get ().size () > max) - { - blocks.get ().erase (blocks.get ().begin ()); - } - } -} - -void nano::gap_cache::erase (nano::block_hash const & hash_a) -{ - nano::lock_guard lock{ mutex }; - blocks.get ().erase (hash_a); -} - -void nano::gap_cache::vote (std::shared_ptr const & vote_a) -{ - nano::lock_guard lock{ mutex }; - for (auto const & hash : vote_a->hashes) - { - auto & gap_blocks_by_hash (blocks.get ()); - auto existing (gap_blocks_by_hash.find (hash)); - if (existing != gap_blocks_by_hash.end () && !existing->bootstrap_started) - { - auto is_new (false); - gap_blocks_by_hash.modify (existing, [&is_new, &vote_a] (nano::gap_information & info) { - auto it = std::find (info.voters.begin (), info.voters.end (), vote_a->account); - is_new = (it == info.voters.end ()); - if (is_new) - { - info.voters.push_back (vote_a->account); - } - }); - - if (is_new) - { - if (bootstrap_check (existing->voters, hash)) - { - gap_blocks_by_hash.modify (existing, [] (nano::gap_information & info) { - info.bootstrap_started = true; - }); - } - } - } - } -} - -bool nano::gap_cache::bootstrap_check (std::vector const & voters_a, nano::block_hash const & hash_a) -{ - nano::uint128_t tally; - for (auto const & voter : voters_a) - { - tally += node.ledger.weight (voter); - } - bool start_bootstrap (false); - if (!node.flags.disable_lazy_bootstrap) - { - if (tally >= node.online_reps.delta ()) - { - start_bootstrap = true; - } - } - else if (!node.flags.disable_legacy_bootstrap && tally > bootstrap_threshold ()) - { - start_bootstrap = true; - } - if (start_bootstrap && !node.ledger.block_or_pruned_exists (hash_a)) - { - bootstrap_start (hash_a); - } - return start_bootstrap; -} - -void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a) -{ - auto node_l (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.bootstrap.gap_cache_bootstrap_start_interval, [node_l, hash_a] () { - if (!node_l->ledger.block_or_pruned_exists (hash_a)) - { - if (!node_l->bootstrap_initiator.in_progress ()) - { - node_l->logger.debug (nano::log::type::gap_cache, "Block {} has enough votes to warrant lazy bootstrapping it", hash_a.to_string ()); - } - if (!node_l->flags.disable_lazy_bootstrap) - { - node_l->bootstrap_initiator.bootstrap_lazy (hash_a); - } - else if (!node_l->flags.disable_legacy_bootstrap) - { - node_l->bootstrap_initiator.bootstrap (); - } - } - }); -} - -nano::uint128_t nano::gap_cache::bootstrap_threshold () -{ - auto result ((node.online_reps.trended () / 256) * node.config.bootstrap_fraction_numerator); - return result; -} - -std::size_t nano::gap_cache::size () -{ - nano::lock_guard lock{ mutex }; - return blocks.size (); -} - -std::unique_ptr nano::collect_container_info (gap_cache & gap_cache, std::string const & name) -{ - auto count = gap_cache.size (); - auto sizeof_element = sizeof (decltype (gap_cache.blocks)::value_type); - auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "blocks", count, sizeof_element })); - return composite; -} diff --git a/nano/node/gap_cache.hpp b/nano/node/gap_cache.hpp deleted file mode 100644 index 118625fd35..0000000000 --- a/nano/node/gap_cache.hpp +++ /dev/null @@ -1,59 +0,0 @@ -#pragma once - -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include - -namespace nano -{ -class node; - -/** For each gap in account chains, track arrival time and voters */ -class gap_information final -{ -public: - std::chrono::steady_clock::time_point arrival; - nano::block_hash hash; - std::vector voters; - bool bootstrap_started{ false }; -}; - -/** Maintains voting and arrival information for gaps (missing source or previous blocks in account chains) */ -class gap_cache final -{ -public: - explicit gap_cache (nano::node &); - void add (nano::block_hash const &, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now ()); - void erase (nano::block_hash const & hash_a); - void vote (std::shared_ptr const &); - bool bootstrap_check (std::vector const &, nano::block_hash const &); - void bootstrap_start (nano::block_hash const & hash_a); - nano::uint128_t bootstrap_threshold (); - std::size_t size (); - // clang-format off - class tag_arrival {}; - class tag_hash {}; - using ordered_gaps = boost::multi_index_container, - boost::multi_index::member>, - boost::multi_index::hashed_unique, - boost::multi_index::member>>>; - ordered_gaps blocks; - // clang-format on - std::size_t const max = 256; - nano::mutex mutex{ mutex_identifier (mutexes::gap_cache) }; - nano::node & node; -}; - -std::unique_ptr collect_container_info (gap_cache & gap_cache, std::string const & name); -} diff --git a/nano/node/gap_tracker.cpp b/nano/node/gap_tracker.cpp deleted file mode 100644 index 35c6e534a5..0000000000 --- a/nano/node/gap_tracker.cpp +++ /dev/null @@ -1,29 +0,0 @@ -#include -#include -#include -#include - -nano::gap_tracker::gap_tracker (nano::gap_cache & gap_cache) : - gap_cache{ gap_cache } -{ -} - -void nano::gap_tracker::connect (nano::block_processor & block_processor) -{ - block_processor.processed.add ([this] (auto const & result, auto const & block) { - switch (result.code) - { - case nano::process_result::gap_previous: - case nano::process_result::gap_source: - observe (block); - break; - default: - break; - } - }); -} - -void nano::gap_tracker::observe (std::shared_ptr block) -{ - gap_cache.add (block->hash ()); -} diff --git a/nano/node/gap_tracker.hpp b/nano/node/gap_tracker.hpp deleted file mode 100644 index 6b8e54f264..0000000000 --- a/nano/node/gap_tracker.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include - -namespace nano -{ -class gap_cache; -class block_processor; -class block; - -// Observes the processed blocks and tracks them (gap_cache) if they are gap blocks. -class gap_tracker -{ -public: - gap_tracker (nano::gap_cache & gap_cache); - void connect (nano::block_processor & block_processor); - -private: - // Block_processor observer - void observe (std::shared_ptr block); - - nano::gap_cache & gap_cache; -}; -} diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 24a2e31158..cda73b2ffb 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -156,7 +156,6 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons unchecked{ config.max_unchecked_blocks, stats, flags.disable_block_processor_unchecked_deletion }, wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), wallets_store (*wallets_store_impl), - gap_cache (*this), ledger (store, stats, network_params.ledger, flags_a.generate_cache), outbound_limiter{ outbound_bandwidth_limiter_config (config) }, // empty `config.peering_port` means the user made no port choice at all; @@ -200,14 +199,12 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons node_seq (seq), block_broadcast{ network, block_arrival, !flags.disable_block_processor_republishing }, block_publisher{ active }, - gap_tracker{ gap_cache }, process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } { logger.debug (nano::log::type::node, "Constructing node..."); block_broadcast.connect (block_processor); block_publisher.connect (block_processor); - gap_tracker.connect (block_processor); process_live_dispatcher.connect (block_processor); unchecked.satisfied.add ([this] (nano::unchecked_info const & info) { this->block_processor.add (info.block); @@ -331,7 +328,6 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons // Representative is defined as online if replying to live votes or rep_crawler queries this->online_reps.observe (vote_a->account); } - this->gap_cache.vote (vote_a); }); // Cancelling local work generation @@ -531,7 +527,6 @@ std::unique_ptr nano::collect_container_info (no { auto composite = std::make_unique (name); composite->add_component (collect_container_info (node.work, "work")); - composite->add_component (collect_container_info (node.gap_cache, "gap_cache")); composite->add_component (collect_container_info (node.ledger, "ledger")); composite->add_component (collect_container_info (node.active, "active")); composite->add_component (collect_container_info (node.bootstrap_initiator, "bootstrap_initiator")); @@ -1371,7 +1366,7 @@ void nano::node::bootstrap_block (const nano::block_hash & hash) if (!ledger.pruning || !store.pruned.exists (store.tx_begin_read (), hash)) { // We don't have the block, try to bootstrap it - gap_cache.bootstrap_start (hash); + // TODO: Use ascending bootstraper to bootstrap block hash } } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index dcdffdcf8d..dbf5d6512f 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -20,8 +20,6 @@ #include #include #include -#include -#include #include #include #include @@ -156,7 +154,6 @@ class node final : public std::enable_shared_from_this nano::unchecked_map unchecked; std::unique_ptr wallets_store_impl; nano::wallets_store & wallets_store; - nano::gap_cache gap_cache; nano::ledger ledger; nano::outbound_bandwidth_limiter outbound_limiter; nano::network network; @@ -195,7 +192,6 @@ class node final : public std::enable_shared_from_this nano::epoch_upgrader epoch_upgrader; nano::block_broadcast block_broadcast; nano::block_publisher block_publisher; - nano::gap_tracker gap_tracker; nano::process_live_dispatcher process_live_dispatcher; std::chrono::steady_clock::time_point const startup_time; From f3c37742e0fa37e2b25b7d4bb9c12fb0d800df73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 16:49:43 +0100 Subject: [PATCH 070/190] Move block observer logic into `active_transactions` (#4421) --- nano/node/CMakeLists.txt | 2 -- nano/node/active_transactions.cpp | 17 +++++++++++++++-- nano/node/active_transactions.hpp | 6 ++++-- nano/node/block_publisher.cpp | 27 --------------------------- nano/node/block_publisher.hpp | 24 ------------------------ nano/node/node.cpp | 5 ++--- nano/node/node.hpp | 2 -- 7 files changed, 21 insertions(+), 62 deletions(-) delete mode 100644 nano/node/block_publisher.cpp delete mode 100644 nano/node/block_publisher.hpp diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index e340508c8f..37278a5058 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -24,8 +24,6 @@ add_library( block_arrival.cpp block_broadcast.cpp block_broadcast.hpp - block_publisher.cpp - block_publisher.hpp blocking_observer.cpp blocking_observer.hpp blockprocessor.hpp diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 88c85c1e5b..01c7535287 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -13,9 +13,10 @@ using namespace std::chrono; -nano::active_transactions::active_transactions (nano::node & node_a, nano::confirmation_height_processor & confirmation_height_processor_a) : - confirmation_height_processor{ confirmation_height_processor_a }, +nano::active_transactions::active_transactions (nano::node & node_a, nano::confirmation_height_processor & confirmation_height_processor_a, nano::block_processor & block_processor_a) : node{ node_a }, + confirmation_height_processor{ confirmation_height_processor_a }, + block_processor{ block_processor_a }, recently_confirmed{ 65536 }, recently_cemented{ node.config.confirmation_history_size }, election_time_to_live{ node_a.network_params.network.is_dev_network () ? 0s : 2s } @@ -31,6 +32,18 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi confirmation_height_processor.add_block_already_cemented_observer ([this] (nano::block_hash const & hash_a) { this->block_already_cemented_callback (hash_a); }); + + // Notify elections about alternative (forked) blocks + block_processor.processed.add ([this] (auto const & result, auto const & block) { + switch (result.code) + { + case nano::process_result::fork: + publish (block); + break; + default: + break; + } + }); } nano::active_transactions::~active_transactions () diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp index ac83c4efa8..c2b945a9a9 100644 --- a/nano/node/active_transactions.hpp +++ b/nano/node/active_transactions.hpp @@ -25,6 +25,7 @@ class node; class active_transactions; class block; class block_sideband; +class block_processor; class election; class vote; class confirmation_height_processor; @@ -130,7 +131,7 @@ class active_transactions final std::unordered_map> blocks; public: - active_transactions (nano::node &, nano::confirmation_height_processor &); + active_transactions (nano::node &, nano::confirmation_height_processor &, nano::block_processor &); ~active_transactions (); void start (); @@ -204,8 +205,9 @@ class active_transactions final void notify_observers (nano::election_status const & status, std::vector const & votes, nano::account const & account, nano::uint128_t amount, bool is_state_send, bool is_state_epoch, nano::account const & pending_account); private: // Dependencies - nano::confirmation_height_processor & confirmation_height_processor; nano::node & node; + nano::confirmation_height_processor & confirmation_height_processor; + nano::block_processor & block_processor; public: recently_confirmed_cache recently_confirmed; diff --git a/nano/node/block_publisher.cpp b/nano/node/block_publisher.cpp deleted file mode 100644 index 1cc77e5edb..0000000000 --- a/nano/node/block_publisher.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include -#include -#include - -nano::block_publisher::block_publisher (nano::active_transactions & active) : - active{ active } -{ -} - -void nano::block_publisher::connect (nano::block_processor & block_processor) -{ - block_processor.processed.add ([this] (auto const & result, auto const & block) { - switch (result.code) - { - case nano::process_result::fork: - observe (block); - break; - default: - break; - } - }); -} - -void nano::block_publisher::observe (std::shared_ptr block) -{ - active.publish (block); -} diff --git a/nano/node/block_publisher.hpp b/nano/node/block_publisher.hpp deleted file mode 100644 index 29a2df906b..0000000000 --- a/nano/node/block_publisher.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include - -namespace nano -{ -class active_transactions; -class block_processor; -class block; - -// This class tracks processed blocks to be published. -class block_publisher -{ -public: - block_publisher (nano::active_transactions & active); - void connect (nano::block_processor & block_processor); - -private: - // Block_processor observer - void observe (std::shared_ptr block); - - nano::active_transactions & active; -}; -} diff --git a/nano/node/node.cpp b/nano/node/node.cpp index cda73b2ffb..64bf414bd9 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -186,7 +186,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons vote_cache{ config.vote_cache, stats }, generator{ config, ledger, wallets, vote_processor, history, network, stats, logger, /* non-final */ false }, final_generator{ config, ledger, wallets, vote_processor, history, network, stats, logger, /* final */ true }, - active (*this, confirmation_height_processor), + active{ *this, confirmation_height_processor, block_processor }, scheduler_impl{ std::make_unique (*this) }, scheduler{ *scheduler_impl }, aggregator (config, stats, generator, final_generator, history, ledger, wallets, active), @@ -198,14 +198,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons startup_time (std::chrono::steady_clock::now ()), node_seq (seq), block_broadcast{ network, block_arrival, !flags.disable_block_processor_republishing }, - block_publisher{ active }, process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } { logger.debug (nano::log::type::node, "Constructing node..."); block_broadcast.connect (block_processor); - block_publisher.connect (block_processor); process_live_dispatcher.connect (block_processor); + unchecked.satisfied.add ([this] (nano::unchecked_info const & info) { this->block_processor.add (info.block); }); diff --git a/nano/node/node.hpp b/nano/node/node.hpp index dbf5d6512f..d5eae05945 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -10,7 +10,6 @@ #include #include #include -#include #include #include #include @@ -191,7 +190,6 @@ class node final : public std::enable_shared_from_this nano::websocket_server websocket; nano::epoch_upgrader epoch_upgrader; nano::block_broadcast block_broadcast; - nano::block_publisher block_publisher; nano::process_live_dispatcher process_live_dispatcher; std::chrono::steady_clock::time_point const startup_time; From c5926cb4efad66ab71dd60db8f2bcb2bd6122aa5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 16:56:40 +0100 Subject: [PATCH 071/190] Adjust election block rebroadcasting (#4423) --- nano/lib/config.hpp | 12 ++++++++---- nano/lib/stats_enums.hpp | 2 ++ nano/node/election.cpp | 27 +++++++++++++++++++++++++-- nano/node/election.hpp | 8 +++++--- 4 files changed, 40 insertions(+), 9 deletions(-) diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index 5db3296c78..a68b02c1b0 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -211,7 +211,8 @@ class network_constants max_peers_per_subnetwork (default_max_peers_per_ip * 4), ipv6_subnetwork_prefix_for_limiting (64), // Equivalent to network prefix /64. peer_dump_interval (std::chrono::seconds (5 * 60)), - vote_broadcast_interval (15 * 1000) + vote_broadcast_interval (15 * 1000), + block_broadcast_interval (150 * 1000) { if (is_live_network ()) { @@ -243,7 +244,8 @@ class network_constants max_peers_per_ip = 20; max_peers_per_subnetwork = max_peers_per_ip * 4; peer_dump_interval = std::chrono::seconds (1); - vote_broadcast_interval = 500; + vote_broadcast_interval = 500ms; + block_broadcast_interval = 500ms; telemetry_request_cooldown = 500ms; telemetry_cache_cutoff = 2000ms; telemetry_request_interval = 500ms; @@ -288,8 +290,10 @@ class network_constants size_t max_peers_per_subnetwork; size_t ipv6_subnetwork_prefix_for_limiting; std::chrono::seconds peer_dump_interval; - /** Time to wait before vote rebroadcasts for active elections (milliseconds) */ - uint64_t vote_broadcast_interval; + + /** Time to wait before rebroadcasts for active elections */ + std::chrono::milliseconds vote_broadcast_interval; + std::chrono::milliseconds block_broadcast_interval; /** We do not reply to telemetry requests made within cooldown period */ std::chrono::milliseconds telemetry_request_cooldown{ 1000 * 15 }; diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 2bfda59d3c..8fc3155763 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -163,6 +163,8 @@ enum class detail : uint8_t generate_vote, generate_vote_normal, generate_vote_final, + broadcast_block_initial, + broadcast_block_repeat, // election types normal, diff --git a/nano/node/election.cpp b/nano/node/election.cpp index ae3afd7ce6..56e86f1b21 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -192,13 +192,35 @@ bool nano::election::failed () const return state_m == nano::election::state_t::expired_unconfirmed; } +bool nano::election::broadcast_block_predicate () const +{ + debug_assert (!mutex.try_lock ()); + + // Broadcast the block if enough time has passed since the last broadcast (or it's the first broadcast) + if (last_block + node.config.network_params.network.block_broadcast_interval < std::chrono::steady_clock::now ()) + { + return true; + } + // Or the current election winner has changed + if (status.winner->hash () != last_block_hash) + { + return true; + } + return false; +} + void nano::election::broadcast_block (nano::confirmation_solicitor & solicitor_a) { - if (base_latency () * 15 < std::chrono::steady_clock::now () - last_block) + debug_assert (!mutex.try_lock ()); + + if (broadcast_block_predicate ()) { if (!solicitor_a.broadcast (*this)) { + node.stats.inc (nano::stat::type::election, last_block_hash.is_zero () ? nano::stat::detail::broadcast_block_initial : nano::stat::detail::broadcast_block_repeat); + last_block = std::chrono::steady_clock::now (); + last_block_hash = status.winner->hash (); } } } @@ -246,6 +268,7 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a break; case nano::election::state_t::confirmed: result = true; // Return true to indicate this election should be cleaned up + broadcast_block (solicitor_a); // Ensure election winner is broadcasted state_change (nano::election::state_t::confirmed, nano::election::state_t::expired_confirmed); break; case nano::election::state_t::expired_unconfirmed: @@ -566,7 +589,7 @@ void nano::election::broadcast_vote_locked (nano::unique_lock & loc { debug_assert (lock.owns_lock ()); - if (std::chrono::steady_clock::now () < last_vote + std::chrono::milliseconds (node.config.network_params.network.vote_broadcast_interval)) + if (std::chrono::steady_clock::now () < last_vote + node.config.network_params.network.vote_broadcast_interval) { return; } diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 48f695c2fe..04dd20980b 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -111,10 +111,11 @@ class election final : public std::enable_shared_from_this std::chrono::steady_clock::duration state_start{ std::chrono::steady_clock::now ().time_since_epoch () }; // These are modified while not holding the mutex from transition_time only - std::chrono::steady_clock::time_point last_block = { std::chrono::steady_clock::now () }; - std::chrono::steady_clock::time_point last_req = {}; + std::chrono::steady_clock::time_point last_block{}; + nano::block_hash last_block_hash{ 0 }; + std::chrono::steady_clock::time_point last_req{}; /** The last time vote for this election was generated */ - std::chrono::steady_clock::time_point last_vote = {}; + std::chrono::steady_clock::time_point last_vote{}; bool valid_change (nano::election::state_t, nano::election::state_t) const; bool state_change (nano::election::state_t, nano::election::state_t); @@ -176,6 +177,7 @@ class election final : public std::enable_shared_from_this nano::election_extended_status current_status_locked () const; // lock_a does not own the mutex on return void confirm_once (nano::unique_lock & lock_a, nano::election_status_type = nano::election_status_type::active_confirmed_quorum); + bool broadcast_block_predicate () const; void broadcast_block (nano::confirmation_solicitor &); void send_confirm_req (nano::confirmation_solicitor &); /** From 1cb607afde2911cc57765ab3d423c82a3319f5c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 12 Nov 2023 15:19:42 +0100 Subject: [PATCH 072/190] Blockprocessor context --- nano/node/active_transactions.cpp | 2 +- nano/node/block_broadcast.cpp | 2 +- nano/node/blocking_observer.cpp | 2 +- nano/node/blockprocessor.cpp | 76 ++++++++++++++--------- nano/node/blockprocessor.hpp | 51 ++++++++++----- nano/node/bootstrap_ascending/service.cpp | 3 +- nano/node/node.cpp | 6 +- nano/node/process_live_dispatcher.cpp | 2 +- 8 files changed, 91 insertions(+), 53 deletions(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 01c7535287..b32a3aced2 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -34,7 +34,7 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi }); // Notify elections about alternative (forked) blocks - block_processor.processed.add ([this] (auto const & result, auto const & block) { + block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { switch (result.code) { case nano::process_result::fork: diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index fc996fc0ea..852f17360f 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -16,7 +16,7 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) { return; } - block_processor.processed.add ([this] (auto const & result, auto const & block) { + block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { switch (result.code) { case nano::process_result::progress: diff --git a/nano/node/blocking_observer.cpp b/nano/node/blocking_observer.cpp index 339b09b84b..6ef14f69b0 100644 --- a/nano/node/blocking_observer.cpp +++ b/nano/node/blocking_observer.cpp @@ -3,7 +3,7 @@ void nano::blocking_observer::connect (nano::block_processor & block_processor) { - block_processor.processed.add ([this] (auto const & result, auto const & block) { + block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { observe (result, block); }); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index c0477b4e01..28ecd84066 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -7,16 +7,15 @@ #include nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) : - next_log (std::chrono::steady_clock::now ()), node (node_a), - write_database_queue (write_database_queue_a) + write_database_queue (write_database_queue_a), + next_log (std::chrono::steady_clock::now ()) { batch_processed.add ([this] (auto const & items) { // For every batch item: notify the 'processed' observer. - for (auto const & item : items) + for (auto const & [result, block, context] : items) { - auto const & [result, block] = item; - processed.notify (result, block); + processed.notify (result, block, context); } }); blocking.connect (*this); @@ -53,7 +52,7 @@ bool nano::block_processor::half_full () return size () >= node.flags.block_processor_full_size / 2; } -void nano::block_processor::add (std::shared_ptr const & block) +void nano::block_processor::add (std::shared_ptr const & block, block_source const source) { if (full ()) { @@ -65,14 +64,14 @@ void nano::block_processor::add (std::shared_ptr const & block) node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work); return; } - add_impl (block); + add_impl (block, source); return; } -std::optional nano::block_processor::add_blocking (std::shared_ptr const & block) +std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) { auto future = blocking.insert (block); - add_impl (block); + add_impl (block, source); condition.notify_all (); std::optional result; try @@ -130,7 +129,7 @@ void nano::block_processor::force (std::shared_ptr const & block_a) { { nano::lock_guard lock{ mutex }; - forced.push_back (block_a); + forced.emplace_back (block_a, context{ block_source::forced, std::chrono::steady_clock::now () }); } condition.notify_all (); } @@ -181,28 +180,52 @@ bool nano::block_processor::have_blocks () return have_blocks_ready (); } -void nano::block_processor::add_impl (std::shared_ptr block) +void nano::block_processor::add_impl (std::shared_ptr block, block_source const source) { { nano::lock_guard guard{ mutex }; - blocks.emplace_back (block); + blocks.emplace_back (block, context{ source, std::chrono::steady_clock::now () }); } condition.notify_all (); } +auto nano::block_processor::next_block () -> std::pair +{ + debug_assert (!mutex.try_lock ()); + + if (forced.empty ()) + { + release_assert (!blocks.empty ()); // Checked before calling this function + + auto entry = blocks.front (); + blocks.pop_front (); + return { entry, false }; // Not forced + } + else + { + auto entry = forced.front (); + forced.pop_front (); + return { entry, true }; // Forced + } +} + auto nano::block_processor::process_batch (nano::unique_lock & lock_a) -> std::deque { std::deque processed; + auto scoped_write_guard = write_database_queue.wait (nano::writer::process_batch); auto transaction (node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); nano::timer timer_l; + lock_a.lock (); + timer_l.start (); // Processing blocks unsigned number_of_blocks_processed (0), number_of_forced_processed (0); auto deadline_reached = [&timer_l, deadline = node.config.block_processor_batch_max_time] { return timer_l.after_deadline (deadline); }; auto processor_batch_reached = [&number_of_blocks_processed, max = node.flags.block_processor_batch_size] { return number_of_blocks_processed >= max; }; auto store_batch_reached = [&number_of_blocks_processed, max = node.store.max_block_write_batch_num ()] { return number_of_blocks_processed >= max; }; + while (have_blocks_ready () && (!deadline_reached () || !processor_batch_reached ()) && !store_batch_reached ()) { // TODO: Cleaner periodical logging @@ -211,33 +234,26 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock node.logger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); } - std::shared_ptr block; - nano::block_hash hash (0); - bool force (false); - if (forced.empty ()) - { - block = blocks.front (); - blocks.pop_front (); - hash = block->hash (); - } - else - { - block = forced.front (); - forced.pop_front (); - hash = block->hash (); - force = true; - number_of_forced_processed++; - } + auto [entry, force] = next_block (); + auto const & [block, context] = entry; + auto const hash = block->hash (); + lock_a.unlock (); + if (force) { + number_of_forced_processed++; rollback_competitor (transaction, *block); } + number_of_blocks_processed++; + auto result = process_one (transaction, block, force); - processed.emplace_back (result, block); + processed.emplace_back (result, block, context); + lock_a.lock (); } + lock_a.unlock (); if (number_of_blocks_processed != 0 && timer_l.stop () > std::chrono::milliseconds (100)) diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index a53fa80761..df681fed4f 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -26,14 +26,35 @@ class write_database_queue; */ class block_processor final { +public: // Context + enum class block_source + { + unknown = 0, + live, + bootstrap, + unchecked, + local, + forced, + }; + + struct context + { + block_source source; + std::chrono::steady_clock::time_point arrival; + }; + + using entry_t = std::pair, context>; + using processed_t = std::tuple, context>; + public: - explicit block_processor (nano::node &, nano::write_database_queue &); + block_processor (nano::node &, nano::write_database_queue &); + void stop (); std::size_t size (); bool full (); bool half_full (); - void add (std::shared_ptr const &); - std::optional add_blocking (std::shared_ptr const & block); + void add (std::shared_ptr const &, block_source = block_source::live); + std::optional add_blocking (std::shared_ptr const & block, block_source); void force (std::shared_ptr const &); bool should_log (); bool have_blocks_ready (); @@ -43,9 +64,7 @@ class block_processor final std::atomic flushing{ false }; public: // Events - using processed_t = std::pair>; - nano::observer_set> processed; - + nano::observer_set, context> processed; // The batch observer feeds the processed obsever nano::observer_set const &> batch_processed; @@ -54,23 +73,27 @@ class block_processor final private: // Roll back block in the ledger that conflicts with 'block' - void rollback_competitor (store::write_transaction const & transaction, nano::block const & block); - nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, bool const = false); + void rollback_competitor (store::write_transaction const &, nano::block const & block); + nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, bool forced = false); void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); std::deque process_batch (nano::unique_lock &); - void add_impl (std::shared_ptr block); + std::pair next_block (); /// @returns + void add_impl (std::shared_ptr block, block_source source); + +private: // Dependencies + nano::node & node; + nano::write_database_queue & write_database_queue; + +private: bool stopped{ false }; bool active{ false }; std::chrono::steady_clock::time_point next_log; - std::deque> blocks; - std::deque> forced; + std::deque blocks; + std::deque forced; nano::condition_variable condition; - nano::node & node; - nano::write_database_queue & write_database_queue; nano::mutex mutex{ mutex_identifier (mutexes::block_processor) }; std::thread processing_thread; friend std::unique_ptr collect_container_info (block_processor & block_processor, std::string const & name); }; -std::unique_ptr collect_container_info (block_processor & block_processor, std::string const & name); } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 76e2aac31a..23cd499113 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -34,10 +34,9 @@ nano::bootstrap_ascending::service::service (nano::node_config & config_a, nano: nano::lock_guard lock{ mutex }; auto transaction = ledger.store.tx_begin_read (); - for (auto const & [result, block] : batch) + for (auto const & [result, block, context] : batch) { debug_assert (block != nullptr); - inspect (transaction, result, *block); } } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 64bf414bd9..e186925bb4 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -206,7 +206,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons process_live_dispatcher.connect (block_processor); unchecked.satisfied.add ([this] (nano::unchecked_info const & info) { - this->block_processor.add (info.block); + block_processor.add (info.block, nano::block_processor::block_source::unchecked); }); vote_cache.rep_weight_query = [this] (nano::account const & rep) { @@ -577,7 +577,7 @@ std::optional nano::node::process_local (std::shared_ptrhash ()); block_broadcast.set_local (block_a); - return block_processor.add_blocking (block_a); + return block_processor.add_blocking (block_a, nano::block_processor::block_source::local); } void nano::node::process_local_async (std::shared_ptr const & block_a) @@ -585,7 +585,7 @@ void nano::node::process_local_async (std::shared_ptr const & block // Add block hash as recently arrived to trigger automatic rebroadcast and election block_arrival.add (block_a->hash ()); // Set current time to trigger automatic rebroadcast and election - block_processor.add (block_a); + block_processor.add (block_a, nano::block_processor::block_source::local); } void nano::node::start () diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index c7a6d16dbf..daaad17f4f 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -20,7 +20,7 @@ void nano::process_live_dispatcher::connect (nano::block_processor & block_proce { block_processor.batch_processed.add ([this] (auto const & batch) { auto const transaction = ledger.store.tx_begin_read (); - for (auto const & [result, block] : batch) + for (auto const & [result, block, context] : batch) { debug_assert (block != nullptr); inspect (result, *block, transaction); From fd7445a74a2468f234c4bd544afff661b137449f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 12 Nov 2023 15:42:40 +0100 Subject: [PATCH 073/190] Remove `block_arrival` --- nano/core_test/node.cpp | 47 --------------------------------- nano/lib/locks.cpp | 2 -- nano/lib/locks.hpp | 1 - nano/node/CMakeLists.txt | 2 -- nano/node/block_arrival.cpp | 35 ------------------------- nano/node/block_arrival.hpp | 49 ----------------------------------- nano/node/block_broadcast.cpp | 10 +++---- nano/node/block_broadcast.hpp | 9 +++---- nano/node/blockprocessor.cpp | 10 ++++++- nano/node/blockprocessor.hpp | 4 +-- nano/node/json_handler.cpp | 1 - nano/node/node.cpp | 11 ++------ nano/node/node.hpp | 2 -- nano/rpc_test/rpc.cpp | 1 - 14 files changed, 21 insertions(+), 163 deletions(-) delete mode 100644 nano/node/block_arrival.cpp delete mode 100644 nano/node/block_arrival.hpp diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index fddf1683d4..0f7410e7f9 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2111,53 +2111,6 @@ TEST (node, block_confirm) ASSERT_TIMELY_EQ (10s, node1.active.recently_cemented.list ().size (), 1); } -TEST (node, block_arrival) -{ - nano::test::system system (1); - auto & node (*system.nodes[0]); - ASSERT_EQ (0, node.block_arrival.arrival.size ()); - nano::block_hash hash1 (1); - node.block_arrival.add (hash1); - ASSERT_EQ (1, node.block_arrival.arrival.size ()); - node.block_arrival.add (hash1); - ASSERT_EQ (1, node.block_arrival.arrival.size ()); - nano::block_hash hash2 (2); - node.block_arrival.add (hash2); - ASSERT_EQ (2, node.block_arrival.arrival.size ()); -} - -TEST (node, block_arrival_size) -{ - nano::test::system system (1); - auto & node (*system.nodes[0]); - auto time (std::chrono::steady_clock::now () - nano::block_arrival::arrival_time_min - std::chrono::seconds (5)); - nano::block_hash hash (0); - for (auto i (0); i < nano::block_arrival::arrival_size_min * 2; ++i) - { - node.block_arrival.arrival.push_back (nano::block_arrival_info{ time, hash }); - ++hash.qwords[0]; - } - ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); - node.block_arrival.recent (0); - ASSERT_EQ (nano::block_arrival::arrival_size_min, node.block_arrival.arrival.size ()); -} - -TEST (node, block_arrival_time) -{ - nano::test::system system (1); - auto & node (*system.nodes[0]); - auto time (std::chrono::steady_clock::now ()); - nano::block_hash hash (0); - for (auto i (0); i < nano::block_arrival::arrival_size_min * 2; ++i) - { - node.block_arrival.arrival.push_back (nano::block_arrival_info{ time, hash }); - ++hash.qwords[0]; - } - ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); - node.block_arrival.recent (0); - ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); -} - TEST (node, confirm_quorum) { nano::test::system system (1); diff --git a/nano/lib/locks.cpp b/nano/lib/locks.cpp index 3217e5e5c8..231ef13c35 100644 --- a/nano/lib/locks.cpp +++ b/nano/lib/locks.cpp @@ -251,8 +251,6 @@ char const * nano::mutex_identifier (mutexes mutex) { case mutexes::active: return "active"; - case mutexes::block_arrival: - return "block_arrival"; case mutexes::block_processor: return "block_processor"; case mutexes::block_uniquer: diff --git a/nano/lib/locks.hpp b/nano/lib/locks.hpp index f8447edff4..1bbe0a7fa1 100644 --- a/nano/lib/locks.hpp +++ b/nano/lib/locks.hpp @@ -20,7 +20,6 @@ bool any_filters_registered (); enum class mutexes { active, - block_arrival, block_processor, block_uniquer, blockstore_cache, diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 37278a5058..3f7c20819f 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -20,8 +20,6 @@ add_library( backlog_population.cpp bandwidth_limiter.hpp bandwidth_limiter.cpp - block_arrival.hpp - block_arrival.cpp block_broadcast.cpp block_broadcast.hpp blocking_observer.cpp diff --git a/nano/node/block_arrival.cpp b/nano/node/block_arrival.cpp deleted file mode 100644 index 914e18dcc0..0000000000 --- a/nano/node/block_arrival.cpp +++ /dev/null @@ -1,35 +0,0 @@ -#include - -bool nano::block_arrival::add (nano::block_hash const & hash_a) -{ - nano::lock_guard lock{ mutex }; - auto now (std::chrono::steady_clock::now ()); - auto inserted (arrival.get ().emplace_back (nano::block_arrival_info{ now, hash_a })); - auto result (!inserted.second); - return result; -} - -bool nano::block_arrival::recent (nano::block_hash const & hash_a) -{ - nano::lock_guard lock{ mutex }; - auto now (std::chrono::steady_clock::now ()); - while (arrival.size () > arrival_size_min && arrival.get ().front ().arrival + arrival_time_min < now) - { - arrival.get ().pop_front (); - } - return arrival.get ().find (hash_a) != arrival.get ().end (); -} - -std::unique_ptr nano::collect_container_info (block_arrival & block_arrival, std::string const & name) -{ - std::size_t count = 0; - { - nano::lock_guard guard{ block_arrival.mutex }; - count = block_arrival.arrival.size (); - } - - auto sizeof_element = sizeof (decltype (block_arrival.arrival)::value_type); - auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "arrival", count, sizeof_element })); - return composite; -} \ No newline at end of file diff --git a/nano/node/block_arrival.hpp b/nano/node/block_arrival.hpp deleted file mode 100644 index 71aa394632..0000000000 --- a/nano/node/block_arrival.hpp +++ /dev/null @@ -1,49 +0,0 @@ -#pragma once - -#include - -#include -#include -#include -#include - -#include - -namespace nano -{ -class block_arrival_info final -{ -public: - std::chrono::steady_clock::time_point arrival; - nano::block_hash hash; -}; - -// This class tracks blocks that are probably live because they arrived in a UDP packet -// This gives a fairly reliable way to differentiate between blocks being inserted via bootstrap or new, live blocks. -class block_arrival final -{ -public: - // Return `true' to indicated an error if the block has already been inserted - bool add (nano::block_hash const &); - bool recent (nano::block_hash const &); - - // clang-format off - class tag_sequence {}; - class tag_hash {}; - - boost::multi_index_container>, - boost::multi_index::hashed_unique, - boost::multi_index::member>>> - arrival; - // clang-format on - - nano::mutex mutex{ mutex_identifier (mutexes::block_arrival) }; - - static std::size_t constexpr arrival_size_min = 8 * 1024; - static std::chrono::seconds constexpr arrival_time_min = std::chrono::seconds (300); -}; - -std::unique_ptr collect_container_info (block_arrival & block_arrival, std::string const & name); -} \ No newline at end of file diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index 852f17360f..4b7e5e772d 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -1,11 +1,9 @@ -#include #include #include #include -nano::block_broadcast::block_broadcast (nano::network & network, nano::block_arrival & block_arrival, bool enabled) : +nano::block_broadcast::block_broadcast (nano::network & network, bool enabled) : network{ network }, - block_arrival{ block_arrival }, enabled{ enabled } { } @@ -20,7 +18,7 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) switch (result.code) { case nano::process_result::progress: - observe (block); + observe (block, context); break; default: break; @@ -29,7 +27,7 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) }); } -void nano::block_broadcast::observe (std::shared_ptr block) +void nano::block_broadcast::observe (std::shared_ptr block, nano::block_processor::context const & context) { nano::unique_lock lock{ mutex }; auto existing = local.find (block); @@ -43,7 +41,7 @@ void nano::block_broadcast::observe (std::shared_ptr block) } else { - if (block_arrival.recent (block->hash ())) + if (context.source != nano::block_processor::block_source::bootstrap) { // Block arrived from realtime traffic, do normal gossip. network.flood_block (block, nano::transport::buffer_drop_policy::limiter); diff --git a/nano/node/block_broadcast.hpp b/nano/node/block_broadcast.hpp index 081d3f2f0b..19055d303b 100644 --- a/nano/node/block_broadcast.hpp +++ b/nano/node/block_broadcast.hpp @@ -1,20 +1,20 @@ #pragma once #include +#include #include #include namespace nano { -class block_arrival; -class block_processor; class network; + // This class tracks blocks that originated from this node. class block_broadcast { public: - block_broadcast (nano::network & network, nano::block_arrival & block_arrival, bool enabled = false); + block_broadcast (nano::network & network, bool enabled = false); // Add batch_processed observer to block_processor if enabled void connect (nano::block_processor & block_processor); // Mark a block as originating locally @@ -23,10 +23,9 @@ class block_broadcast private: // Block_processor observer - void observe (std::shared_ptr block); + void observe (std::shared_ptr block, nano::block_processor::context const &); nano::network & network; - nano::block_arrival & block_arrival; std::unordered_set> local; // Blocks originated on this node nano::mutex mutex; bool enabled; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 28ecd84066..1ebad06c22 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -6,6 +6,10 @@ #include +/* + * block_processor + */ + nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) : node (node_a), write_database_queue (write_database_queue_a), @@ -184,7 +188,7 @@ void nano::block_processor::add_impl (std::shared_ptr block, block_ { { nano::lock_guard guard{ mutex }; - blocks.emplace_back (block, context{ source, std::chrono::steady_clock::now () }); + blocks.emplace_back (block, context{ source }); } condition.notify_all (); } @@ -377,3 +381,7 @@ std::unique_ptr nano::collect_container_info (bl composite->add_component (std::make_unique (container_info{ "forced", forced_count, sizeof (decltype (block_processor.forced)::value_type) })); return composite; } + +/* + * context + */ diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index df681fed4f..ad266be0aa 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -39,8 +39,8 @@ class block_processor final struct context { - block_source source; - std::chrono::steady_clock::time_point arrival; + block_source const source{}; + std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () }; }; using entry_t = std::pair, context>; diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 58af00f1c5..91034d0510 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1214,7 +1214,6 @@ void nano::json_handler::block_confirm () nano::election_status status{ block_l, 0, 0, std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height }; node.active.recently_cemented.put (status); // Trigger callback for confirmed block - node.block_arrival.add (hash); auto account (node.ledger.account (transaction, hash)); bool error_or_pruned (false); auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index e186925bb4..01d98b2556 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -197,7 +197,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons epoch_upgrader{ *this, ledger, store, network_params, logger }, startup_time (std::chrono::steady_clock::now ()), node_seq (seq), - block_broadcast{ network, block_arrival, !flags.disable_block_processor_republishing }, + block_broadcast{ network, !flags.disable_block_processor_republishing }, process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } { logger.debug (nano::log::type::node, "Constructing node..."); @@ -241,7 +241,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons { observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { auto block_a (status_a.winner); - if ((status_a.type == nano::election_status_type::active_confirmed_quorum || status_a.type == nano::election_status_type::active_confirmation_height) && this->block_arrival.recent (block_a->hash ())) + if ((status_a.type == nano::election_status_type::active_confirmed_quorum || status_a.type == nano::election_status_type::active_confirmation_height)) { auto node_l (shared_from_this ()); background ([node_l, block_a, account_a, amount_a, is_state_send_a, is_state_epoch_a] () { @@ -538,7 +538,6 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (collect_container_info (node.vote_processor, "vote_processor")); composite->add_component (collect_container_info (node.rep_crawler, "rep_crawler")); composite->add_component (collect_container_info (node.block_processor, "block_processor")); - composite->add_component (collect_container_info (node.block_arrival, "block_arrival")); composite->add_component (collect_container_info (node.online_reps, "online_reps")); composite->add_component (collect_container_info (node.history, "history")); composite->add_component (node.block_uniquer.collect_container_info ("block_uniquer")); @@ -557,7 +556,6 @@ std::unique_ptr nano::collect_container_info (no void nano::node::process_active (std::shared_ptr const & incoming) { - block_arrival.add (incoming->hash ()); block_processor.add (incoming); } @@ -574,17 +572,12 @@ nano::process_return nano::node::process (nano::block & block) std::optional nano::node::process_local (std::shared_ptr const & block_a) { - // Add block hash as recently arrived to trigger automatic rebroadcast and election - block_arrival.add (block_a->hash ()); block_broadcast.set_local (block_a); return block_processor.add_blocking (block_a, nano::block_processor::block_source::local); } void nano::node::process_local_async (std::shared_ptr const & block_a) { - // Add block hash as recently arrived to trigger automatic rebroadcast and election - block_arrival.add (block_a->hash ()); - // Set current time to trigger automatic rebroadcast and election block_processor.add (block_a, nano::block_processor::block_source::local); } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index d5eae05945..19e5a7a2ab 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -168,7 +167,6 @@ class node final : public std::enable_shared_from_this nano::vote_processor vote_processor; unsigned warmed_up; nano::block_processor block_processor; - nano::block_arrival block_arrival; nano::local_vote_history history; nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 291e0036fd..3c4d2337d6 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -4431,7 +4431,6 @@ TEST (rpc, populate_backlog) .work (*node->work_generate_blocking (latest)) .build (); ASSERT_EQ (nano::process_result::progress, node->process (*send).code); - ASSERT_FALSE (node->block_arrival.recent (send->hash ())); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; From f1cf12dbd6de124dac8c7eee5361debe3d50ff4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 17:45:22 +0100 Subject: [PATCH 074/190] Simplify `block_broadcast` --- nano/node/block_broadcast.cpp | 29 ++--------------------------- nano/node/block_broadcast.hpp | 7 +------ nano/node/node.cpp | 1 - 3 files changed, 3 insertions(+), 34 deletions(-) diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index 4b7e5e772d..ec2162d1d4 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -23,17 +23,12 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) default: break; } - erase (block); }); } -void nano::block_broadcast::observe (std::shared_ptr block, nano::block_processor::context const & context) +void nano::block_broadcast::observe (std::shared_ptr const & block, nano::block_processor::context const & context) { - nano::unique_lock lock{ mutex }; - auto existing = local.find (block); - auto local_l = existing != local.end (); - lock.unlock (); - if (local_l) + if (context.source == nano::block_processor::block_source::local) { // Block created on this node // Perform more agressive initial flooding @@ -53,23 +48,3 @@ void nano::block_broadcast::observe (std::shared_ptr block, nano::b } } } - -void nano::block_broadcast::set_local (std::shared_ptr block) -{ - if (!enabled) - { - return; - } - nano::lock_guard lock{ mutex }; - local.insert (block); -} - -void nano::block_broadcast::erase (std::shared_ptr block) -{ - if (!enabled) - { - return; - } - nano::lock_guard lock{ mutex }; - local.erase (block); -} diff --git a/nano/node/block_broadcast.hpp b/nano/node/block_broadcast.hpp index 19055d303b..4129ddc415 100644 --- a/nano/node/block_broadcast.hpp +++ b/nano/node/block_broadcast.hpp @@ -17,17 +17,12 @@ class block_broadcast block_broadcast (nano::network & network, bool enabled = false); // Add batch_processed observer to block_processor if enabled void connect (nano::block_processor & block_processor); - // Mark a block as originating locally - void set_local (std::shared_ptr block); - void erase (std::shared_ptr block); private: // Block_processor observer - void observe (std::shared_ptr block, nano::block_processor::context const &); + void observe (std::shared_ptr const & block, nano::block_processor::context const &); nano::network & network; - std::unordered_set> local; // Blocks originated on this node - nano::mutex mutex; bool enabled; }; } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 01d98b2556..ccdeaaf0ed 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -572,7 +572,6 @@ nano::process_return nano::node::process (nano::block & block) std::optional nano::node::process_local (std::shared_ptr const & block_a) { - block_broadcast.set_local (block_a); return block_processor.add_blocking (block_a, nano::block_processor::block_source::local); } From ba7120ca53b68fa1fea030afe1446e0ac9ae7d83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 12 Nov 2023 16:17:36 +0100 Subject: [PATCH 075/190] Remove `blocking_observer` --- nano/core_test/active_transactions.cpp | 6 +++ nano/node/CMakeLists.txt | 2 - nano/node/blocking_observer.cpp | 62 ---------------------- nano/node/blocking_observer.hpp | 32 ----------- nano/node/blockprocessor.cpp | 73 ++++++++++++++++---------- nano/node/blockprocessor.hpp | 34 ++++++++---- nano/secure/common.cpp | 6 +++ nano/secure/common.hpp | 6 ++- 8 files changed, 84 insertions(+), 137 deletions(-) delete mode 100644 nano/node/blocking_observer.cpp delete mode 100644 nano/node/blocking_observer.hpp diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 910a518cb9..cf8676875d 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -190,6 +190,12 @@ TEST (active_transactions, keep_local) auto const send4 = wallet.send_action (nano::dev::genesis_key.pub, key4.pub, node.config.receive_minimum.number ()); auto const send5 = wallet.send_action (nano::dev::genesis_key.pub, key5.pub, node.config.receive_minimum.number ()); auto const send6 = wallet.send_action (nano::dev::genesis_key.pub, key6.pub, node.config.receive_minimum.number ()); + ASSERT_NE (nullptr, send1); + ASSERT_NE (nullptr, send2); + ASSERT_NE (nullptr, send3); + ASSERT_NE (nullptr, send4); + ASSERT_NE (nullptr, send5); + ASSERT_NE (nullptr, send6); // force-confirm blocks for (auto const & block : { send1, send2, send3, send4, send5, send6 }) diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 3f7c20819f..4452df575c 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -22,8 +22,6 @@ add_library( bandwidth_limiter.cpp block_broadcast.cpp block_broadcast.hpp - blocking_observer.cpp - blocking_observer.hpp blockprocessor.hpp blockprocessor.cpp bootstrap/block_deserializer.hpp diff --git a/nano/node/blocking_observer.cpp b/nano/node/blocking_observer.cpp deleted file mode 100644 index 6ef14f69b0..0000000000 --- a/nano/node/blocking_observer.cpp +++ /dev/null @@ -1,62 +0,0 @@ -#include -#include - -void nano::blocking_observer::connect (nano::block_processor & block_processor) -{ - block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { - observe (result, block); - }); -} - -void nano::blocking_observer::stop () -{ - nano::unique_lock lock{ mutex }; - stopped = true; - auto discard = std::move (blocking); - // Signal broken promises outside lock - lock.unlock (); - discard.clear (); // ~promise future_error -} - -void nano::blocking_observer::observe (nano::process_return const & result, std::shared_ptr block) -{ - nano::unique_lock lock{ mutex }; - auto existing = blocking.find (block); - if (existing != blocking.end ()) - { - auto promise = std::move (existing->second); - blocking.erase (existing); - // Signal promise outside of lock - lock.unlock (); - promise.set_value (result); - } -} - -std::future nano::blocking_observer::insert (std::shared_ptr block) -{ - nano::lock_guard lock{ mutex }; - if (stopped) - { - std::promise promise; - return promise.get_future (); // ~promise future_error - } - auto iterator = blocking.emplace (block, std::promise{}); - return iterator->second.get_future (); -} - -bool nano::blocking_observer::exists (std::shared_ptr block) -{ - nano::lock_guard lock{ mutex }; - auto existing = blocking.find (block); - return existing != blocking.end (); -} - -void nano::blocking_observer::erase (std::shared_ptr block) -{ - nano::lock_guard lock{ mutex }; - auto existing = blocking.find (block); - if (existing != blocking.end ()) - { - blocking.erase (existing); - } -} \ No newline at end of file diff --git a/nano/node/blocking_observer.hpp b/nano/node/blocking_observer.hpp deleted file mode 100644 index bd97141224..0000000000 --- a/nano/node/blocking_observer.hpp +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -#include -#include - -#include -#include -#include - -namespace nano -{ -class block; -class block_processor; -// Observer that facilitates a blocking call to block processing which is done asynchronosly by the block_processor -class blocking_observer -{ -public: - void connect (nano::block_processor & block_processor); - // Stop the observer and trigger broken promise exceptions - void stop (); - // Block processor observer - void observe (nano::process_return const & result, std::shared_ptr block); - [[nodiscard]] std::future insert (std::shared_ptr block); - bool exists (std::shared_ptr block); - void erase (std::shared_ptr block); - -private: - std::unordered_multimap, std::promise> blocking; - bool stopped{ false }; - nano::mutex mutex; -}; -} diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 1ebad06c22..1b2727183a 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -6,6 +6,26 @@ #include +/* + * block_processor::context + */ + +nano::block_processor::context::context (nano::block_processor::block_source source_a) : + source{ source_a } +{ + debug_assert (source != nano::block_processor::block_source::unknown); +} + +auto nano::block_processor::context::get_future () -> std::future +{ + return promise.get_future (); +} + +void nano::block_processor::context::set_result (result_t const & result) +{ + promise.set_value (result); +} + /* * block_processor */ @@ -22,7 +42,6 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas processed.notify (result, block, context); } }); - blocking.connect (*this); processing_thread = std::thread ([this] () { nano::thread_role::set (nano::thread_role::name::block_processing); this->process_blocks (); @@ -36,7 +55,6 @@ void nano::block_processor::stop () stopped = true; } condition.notify_all (); - blocking.stop (); nano::join_or_pass (processing_thread); } @@ -68,33 +86,28 @@ void nano::block_processor::add (std::shared_ptr const & block, blo node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work); return; } - add_impl (block, source); + add_impl (block, context{ source }); return; } std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) { - auto future = blocking.insert (block); - add_impl (block, source); - condition.notify_all (); - std::optional result; + context ctx{ source }; + auto future = ctx.get_future (); + add_impl (block, std::move (ctx)); try { auto status = future.wait_for (node.config.block_process_timeout); debug_assert (status != std::future_status::deferred); if (status == std::future_status::ready) { - result = future.get (); - } - else - { - blocking.erase (block); + return future.get (); } } catch (std::future_error const &) { } - return result; + return std::nullopt; } void nano::block_processor::rollback_competitor (store::write_transaction const & transaction, nano::block const & block) @@ -133,7 +146,7 @@ void nano::block_processor::force (std::shared_ptr const & block_a) { { nano::lock_guard lock{ mutex }; - forced.emplace_back (block_a, context{ block_source::forced, std::chrono::steady_clock::now () }); + forced.emplace_back (block_a, context{ block_source::forced }); } condition.notify_all (); } @@ -147,8 +160,16 @@ void nano::block_processor::process_blocks () { active = true; lock.unlock (); + auto processed = process_batch (lock); + + for (auto & [result, block, context] : processed) + { + context.set_result (result); + } + batch_processed.notify (processed); + lock.lock (); active = false; } @@ -184,11 +205,11 @@ bool nano::block_processor::have_blocks () return have_blocks_ready (); } -void nano::block_processor::add_impl (std::shared_ptr block, block_source const source) +void nano::block_processor::add_impl (std::shared_ptr block, context ctx) { { nano::lock_guard guard{ mutex }; - blocks.emplace_back (block, context{ source }); + blocks.emplace_back (block, std::move (ctx)); } condition.notify_all (); } @@ -201,21 +222,21 @@ auto nano::block_processor::next_block () -> std::pair { release_assert (!blocks.empty ()); // Checked before calling this function - auto entry = blocks.front (); + auto entry = std::move (blocks.front ()); blocks.pop_front (); - return { entry, false }; // Not forced + return { std::move (entry), false }; // Not forced } else { - auto entry = forced.front (); + auto entry = std::move (forced.front ()); forced.pop_front (); - return { entry, true }; // Forced + return { std::move (entry), true }; // Forced } } -auto nano::block_processor::process_batch (nano::unique_lock & lock_a) -> std::deque +auto nano::block_processor::process_batch (nano::unique_lock & lock_a) -> processed_batch_t { - std::deque processed; + processed_batch_t processed; auto scoped_write_guard = write_database_queue.wait (nano::writer::process_batch); auto transaction (node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); @@ -239,7 +260,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock } auto [entry, force] = next_block (); - auto const & [block, context] = entry; + auto & [block, context] = entry; auto const hash = block->hash (); lock_a.unlock (); @@ -253,7 +274,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock number_of_blocks_processed++; auto result = process_one (transaction, block, force); - processed.emplace_back (result, block, context); + processed.emplace_back (result, block, std::move (context)); lock_a.lock (); } @@ -381,7 +402,3 @@ std::unique_ptr nano::collect_container_info (bl composite->add_component (std::make_unique (container_info{ "forced", forced_count, sizeof (decltype (block_processor.forced)::value_type) })); return composite; } - -/* - * context - */ diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index ad266be0aa..672c8df0f9 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -2,12 +2,12 @@ #include #include -#include #include #include #include #include +#include #include namespace nano::store @@ -37,14 +37,26 @@ class block_processor final forced, }; - struct context + class context { - block_source const source{}; + public: + explicit context (block_source); + + block_source const source; std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () }; + + public: + using result_t = nano::process_return; + std::future get_future (); + + private: + void set_result (result_t const &); + std::promise promise; + + friend class block_processor; }; using entry_t = std::pair, context>; - using processed_t = std::tuple, context>; public: block_processor (nano::node &, nano::write_database_queue &); @@ -64,21 +76,21 @@ class block_processor final std::atomic flushing{ false }; public: // Events - nano::observer_set, context> processed; - // The batch observer feeds the processed obsever - nano::observer_set const &> batch_processed; + using processed_t = std::tuple, context>; + using processed_batch_t = std::deque; -private: - blocking_observer blocking; + // The batch observer feeds the processed obsever + nano::observer_set const &, context const &> processed; + nano::observer_set batch_processed; private: // Roll back block in the ledger that conflicts with 'block' void rollback_competitor (store::write_transaction const &, nano::block const & block); nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, bool forced = false); void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); - std::deque process_batch (nano::unique_lock &); + processed_batch_t process_batch (nano::unique_lock &); std::pair next_block (); /// @returns - void add_impl (std::shared_ptr block, block_source source); + void add_impl (std::shared_ptr block, context); private: // Dependencies nano::node & node; diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 2fe551a788..fca9c57335 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -15,6 +15,7 @@ #include #include +#include size_t constexpr nano::send_block::size; size_t constexpr nano::receive_block::size; @@ -496,6 +497,11 @@ void nano::generate_cache::enable_all () account_count = true; } +std::string_view nano::to_string (nano::process_result process_result) +{ + return magic_enum::enum_name (process_result); +} + nano::stat::detail nano::to_stat_detail (nano::process_result process_result) { auto value = magic_enum::enum_cast (magic_enum::enum_name (process_result)); diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 503d4d1271..190b8561cc 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -270,6 +270,10 @@ enum class process_result block_position, // This block cannot follow the previous block insufficient_work // Insufficient work for this block, even though it passed the minimal validation }; + +std::string_view to_string (process_result); +nano::stat::detail to_stat_detail (process_result); + class process_return final { public: @@ -282,8 +286,6 @@ enum class tally_result confirm }; -nano::stat::detail to_stat_detail (process_result); - class network_params; /** Genesis keys and ledger constants for network variants */ From 40ebd8c3741b0fb42a125d9d36865ddc3fd25f13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 5 Feb 2024 20:35:26 +0100 Subject: [PATCH 076/190] Blockprocessor entry struct --- nano/node/blockprocessor.cpp | 42 +++++++++++++++++++++--------------- nano/node/blockprocessor.hpp | 17 ++++++++++----- 2 files changed, 37 insertions(+), 22 deletions(-) diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 1b2727183a..c73f421f69 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -87,7 +87,6 @@ void nano::block_processor::add (std::shared_ptr const & block, blo return; } add_impl (block, context{ source }); - return; } std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) @@ -146,7 +145,7 @@ void nano::block_processor::force (std::shared_ptr const & block_a) { { nano::lock_guard lock{ mutex }; - forced.emplace_back (block_a, context{ block_source::forced }); + forced.emplace_back (entry{ block_a, context{ block_source::forced } }); } condition.notify_all (); } @@ -162,7 +161,9 @@ void nano::block_processor::process_blocks () lock.unlock (); auto processed = process_batch (lock); + debug_assert (!lock.owns_lock ()); + // Set results for futures when not holding the lock for (auto & [result, block, context] : processed) { context.set_result (result); @@ -207,31 +208,36 @@ bool nano::block_processor::have_blocks () void nano::block_processor::add_impl (std::shared_ptr block, context ctx) { + release_assert (ctx.source != nano::block_processor::block_source::forced); { nano::lock_guard guard{ mutex }; - blocks.emplace_back (block, std::move (ctx)); + blocks.emplace_back (entry{ block, std::move (ctx) }); } condition.notify_all (); } -auto nano::block_processor::next_block () -> std::pair +auto nano::block_processor::next () -> entry { debug_assert (!mutex.try_lock ()); + debug_assert (!blocks.empty () || !forced.empty ()); // This should be checked before calling next - if (forced.empty ()) + if (!blocks.empty ()) { - release_assert (!blocks.empty ()); // Checked before calling this function - - auto entry = std::move (blocks.front ()); + entry entry = std::move (blocks.front ()); + release_assert (entry.ctx.source != nano::block_processor::block_source::forced); blocks.pop_front (); - return { std::move (entry), false }; // Not forced + return entry; } - else + + if (!forced.empty ()) { - auto entry = std::move (forced.front ()); + entry entry = std::move (forced.front ()); + release_assert (entry.ctx.source == nano::block_processor::block_source::forced); forced.pop_front (); - return { std::move (entry), true }; // Forced + return entry; } + + release_assert (false, "next() called when no blocks are ready"); } auto nano::block_processor::process_batch (nano::unique_lock & lock_a) -> processed_batch_t @@ -259,9 +265,11 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock node.logger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); } - auto [entry, force] = next_block (); - auto & [block, context] = entry; + entry entry = next (); + context ctx = std::move (entry.ctx); + auto const block = entry.block; auto const hash = block->hash (); + bool const force = ctx.source == nano::block_processor::block_source::forced; lock_a.unlock (); @@ -273,8 +281,8 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock number_of_blocks_processed++; - auto result = process_one (transaction, block, force); - processed.emplace_back (result, block, std::move (context)); + auto result = process_one (transaction, block, ctx, force); + processed.emplace_back (result, block, std::move (ctx)); lock_a.lock (); } @@ -289,7 +297,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock return processed; } -nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, std::shared_ptr block, bool const forced_a) +nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, std::shared_ptr block, context const & context, bool const forced_a) { nano::process_return result; auto hash (block->hash ()); diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 672c8df0f9..a28c549059 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -56,7 +56,12 @@ class block_processor final friend class block_processor; }; - using entry_t = std::pair, context>; +private: + struct entry + { + std::shared_ptr block; + block_processor::context ctx; + }; public: block_processor (nano::node &, nano::write_database_queue &); @@ -86,10 +91,10 @@ class block_processor final private: // Roll back block in the ledger that conflicts with 'block' void rollback_competitor (store::write_transaction const &, nano::block const & block); - nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, bool forced = false); + nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, context const &, bool forced = false); void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); processed_batch_t process_batch (nano::unique_lock &); - std::pair next_block (); /// @returns + entry next (); void add_impl (std::shared_ptr block, context); private: // Dependencies @@ -99,9 +104,11 @@ class block_processor final private: bool stopped{ false }; bool active{ false }; + + std::deque blocks; + std::deque forced; + std::chrono::steady_clock::time_point next_log; - std::deque blocks; - std::deque forced; nano::condition_variable condition; nano::mutex mutex{ mutex_identifier (mutexes::block_processor) }; std::thread processing_thread; From 1cdea1d0f72902cb59620045982168b2afebca63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 12 Nov 2023 23:11:52 +0100 Subject: [PATCH 077/190] Track processed block source stats --- nano/lib/stats_enums.hpp | 9 +++++++++ nano/node/blockprocessor.cpp | 17 ++++++++++++++--- nano/node/blockprocessor.hpp | 2 ++ 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 8fc3155763..e72e3607b9 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -36,6 +36,7 @@ enum class type : uint8_t vote_cache, hinting, blockprocessor, + blockprocessor_sources, bootstrap_server, active, active_started, @@ -71,6 +72,7 @@ enum class detail : uint8_t top, none, success, + unknown, // processing queue queue, @@ -110,6 +112,13 @@ enum class detail : uint8_t representative_mismatch, block_position, + // blockprocessor result + live, + bootstrap, + unchecked, + local, + forced, + // message specific not_a_type, invalid, diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index c73f421f69..1eac1aff95 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -6,6 +6,8 @@ #include +#include + /* * block_processor::context */ @@ -299,13 +301,15 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, std::shared_ptr block, context const & context, bool const forced_a) { - nano::process_return result; - auto hash (block->hash ()); - result = node.ledger.process (transaction_a, *block); + auto const hash = block->hash (); + nano::process_return result = node.ledger.process (transaction_a, *block); node.stats.inc (nano::stat::type::blockprocessor, to_stat_detail (result.code)); + node.stats.inc (nano::stat::type::blockprocessor_sources, to_stat_detail (context.source)); node.logger.trace (nano::log::type::blockprocessor, nano::log::detail::block_processed, nano::log::arg{ "result", result.code }, + nano::log::arg{ "source", context.source }, + nano::log::arg{ "arrival", nano::log::microseconds (context.arrival) }, nano::log::arg{ "forced", forced_a }, nano::log::arg{ "block", block }); @@ -410,3 +414,10 @@ std::unique_ptr nano::collect_container_info (bl composite->add_component (std::make_unique (container_info{ "forced", forced_count, sizeof (decltype (block_processor.forced)::value_type) })); return composite; } + +nano::stat::detail nano::to_stat_detail (block_processor::block_source type) +{ + auto value = magic_enum::enum_cast (magic_enum::enum_name (type)); + debug_assert (value); + return value.value_or (nano::stat::detail{}); +} diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index a28c549059..8b40613079 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -115,4 +115,6 @@ class block_processor final friend std::unique_ptr collect_container_info (block_processor & block_processor, std::string const & name); }; + +nano::stat::detail to_stat_detail (block_processor::block_source); } From 6fc74c8ccbb7edeb3ced8e9f55eaeb0b744fb579 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 18:41:01 +0100 Subject: [PATCH 078/190] Move `block_source` enum --- nano/node/block_broadcast.cpp | 4 ++-- nano/node/blockprocessor.cpp | 14 +++++++------- nano/node/blockprocessor.hpp | 24 ++++++++++++------------ nano/node/node.cpp | 6 +++--- 4 files changed, 24 insertions(+), 24 deletions(-) diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index ec2162d1d4..e3f2fc561c 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -28,7 +28,7 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) void nano::block_broadcast::observe (std::shared_ptr const & block, nano::block_processor::context const & context) { - if (context.source == nano::block_processor::block_source::local) + if (context.source == nano::block_source::local) { // Block created on this node // Perform more agressive initial flooding @@ -36,7 +36,7 @@ void nano::block_broadcast::observe (std::shared_ptr const & block, } else { - if (context.source != nano::block_processor::block_source::bootstrap) + if (context.source != nano::block_source::bootstrap) { // Block arrived from realtime traffic, do normal gossip. network.flood_block (block, nano::transport::buffer_drop_policy::limiter); diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 1eac1aff95..0e33234fd3 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -12,10 +12,10 @@ * block_processor::context */ -nano::block_processor::context::context (nano::block_processor::block_source source_a) : +nano::block_processor::context::context (nano::block_source source_a) : source{ source_a } { - debug_assert (source != nano::block_processor::block_source::unknown); + debug_assert (source != nano::block_source::unknown); } auto nano::block_processor::context::get_future () -> std::future @@ -210,7 +210,7 @@ bool nano::block_processor::have_blocks () void nano::block_processor::add_impl (std::shared_ptr block, context ctx) { - release_assert (ctx.source != nano::block_processor::block_source::forced); + release_assert (ctx.source != nano::block_source::forced); { nano::lock_guard guard{ mutex }; blocks.emplace_back (entry{ block, std::move (ctx) }); @@ -226,7 +226,7 @@ auto nano::block_processor::next () -> entry if (!blocks.empty ()) { entry entry = std::move (blocks.front ()); - release_assert (entry.ctx.source != nano::block_processor::block_source::forced); + release_assert (entry.ctx.source != nano::block_source::forced); blocks.pop_front (); return entry; } @@ -234,7 +234,7 @@ auto nano::block_processor::next () -> entry if (!forced.empty ()) { entry entry = std::move (forced.front ()); - release_assert (entry.ctx.source == nano::block_processor::block_source::forced); + release_assert (entry.ctx.source == nano::block_source::forced); forced.pop_front (); return entry; } @@ -271,7 +271,7 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock context ctx = std::move (entry.ctx); auto const block = entry.block; auto const hash = block->hash (); - bool const force = ctx.source == nano::block_processor::block_source::forced; + bool const force = ctx.source == nano::block_source::forced; lock_a.unlock (); @@ -415,7 +415,7 @@ std::unique_ptr nano::collect_container_info (bl return composite; } -nano::stat::detail nano::to_stat_detail (block_processor::block_source type) +nano::stat::detail nano::to_stat_detail (nano::block_source type) { auto value = magic_enum::enum_cast (magic_enum::enum_name (type)); debug_assert (value); diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 8b40613079..31542b44c6 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -20,6 +20,18 @@ namespace nano class node; class write_database_queue; +enum class block_source +{ + unknown = 0, + live, + bootstrap, + unchecked, + local, + forced, +}; + +nano::stat::detail to_stat_detail (block_source); + /** * Processing blocks is a potentially long IO operation. * This class isolates block insertion from other operations like servicing network operations @@ -27,16 +39,6 @@ class write_database_queue; class block_processor final { public: // Context - enum class block_source - { - unknown = 0, - live, - bootstrap, - unchecked, - local, - forced, - }; - class context { public: @@ -115,6 +117,4 @@ class block_processor final friend std::unique_ptr collect_container_info (block_processor & block_processor, std::string const & name); }; - -nano::stat::detail to_stat_detail (block_processor::block_source); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index ccdeaaf0ed..884a0ae848 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -206,7 +206,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons process_live_dispatcher.connect (block_processor); unchecked.satisfied.add ([this] (nano::unchecked_info const & info) { - block_processor.add (info.block, nano::block_processor::block_source::unchecked); + block_processor.add (info.block, nano::block_source::unchecked); }); vote_cache.rep_weight_query = [this] (nano::account const & rep) { @@ -572,12 +572,12 @@ nano::process_return nano::node::process (nano::block & block) std::optional nano::node::process_local (std::shared_ptr const & block_a) { - return block_processor.add_blocking (block_a, nano::block_processor::block_source::local); + return block_processor.add_blocking (block_a, nano::block_source::local); } void nano::node::process_local_async (std::shared_ptr const & block_a) { - block_processor.add (block_a, nano::block_processor::block_source::local); + block_processor.add (block_a, nano::block_source::local); } void nano::node::start () From aa1ef3144b1b4ef1bd421da4a992e58cbf87a0a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 18:51:55 +0100 Subject: [PATCH 079/190] Add `bootstrap_legacy` source --- nano/lib/stats_enums.hpp | 1 + nano/node/blockprocessor.hpp | 1 + nano/node/bootstrap/bootstrap_attempt.cpp | 2 +- nano/node/bootstrap/bootstrap_lazy.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 2 +- 5 files changed, 5 insertions(+), 3 deletions(-) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index e72e3607b9..9a726472e7 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -115,6 +115,7 @@ enum class detail : uint8_t // blockprocessor result live, bootstrap, + bootstrap_legacy, unchecked, local, forced, diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 31542b44c6..bf3c59ef04 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -25,6 +25,7 @@ enum class block_source unknown = 0, live, bootstrap, + bootstrap_legacy, unchecked, local, forced, diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 8d892db2e2..3f78beff2a 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -133,7 +133,7 @@ bool nano::bootstrap_attempt::process_block (std::shared_ptr const } else { - node_l->block_processor.add (block_a); + node_l->block_processor.add (block_a, nano::block_source::bootstrap_legacy); } return stop_pull; } diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 0d3dbc9408..d69916a9c9 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -311,7 +311,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrblock_processor.add (block_a); + node->block_processor.add (block_a, nano::block_source::bootstrap_legacy); } // Force drop lazy bootstrap connection for long bulk_pull if (pull_blocks_processed > max_blocks) diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 23cd499113..d091b64464 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -387,7 +387,7 @@ void nano::bootstrap_ascending::service::process (const nano::asc_pull_ack::bloc for (auto & block : response.blocks) { - block_processor.add (block); + block_processor.add (block, nano::block_source::bootstrap); } nano::lock_guard lock{ mutex }; throttle.add (true); From 124421bfefe8add44058caf628b8046a699b9dfe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 8 Feb 2024 19:12:15 +0100 Subject: [PATCH 080/190] Name conflict --- nano/node/active_transactions.cpp | 2 +- nano/node/block_broadcast.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/blockprocessor.hpp | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index b32a3aced2..74f1ba4e9f 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -34,7 +34,7 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi }); // Notify elections about alternative (forked) blocks - block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { + block_processor.block_processed.add ([this] (auto const & result, auto const & block, auto const & context) { switch (result.code) { case nano::process_result::fork: diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index e3f2fc561c..2fb61e6a17 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -14,7 +14,7 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) { return; } - block_processor.processed.add ([this] (auto const & result, auto const & block, auto const & context) { + block_processor.block_processed.add ([this] (auto const & result, auto const & block, auto const & context) { switch (result.code) { case nano::process_result::progress: diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 0e33234fd3..3130da4997 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -41,7 +41,7 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas // For every batch item: notify the 'processed' observer. for (auto const & [result, block, context] : items) { - processed.notify (result, block, context); + block_processed.notify (result, block, context); } }); processing_thread = std::thread ([this] () { diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index bf3c59ef04..97dbb71e63 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -87,8 +87,8 @@ class block_processor final using processed_t = std::tuple, context>; using processed_batch_t = std::deque; - // The batch observer feeds the processed obsever - nano::observer_set const &, context const &> processed; + // The batch observer feeds the processed observer + nano::observer_set const &, context const &> block_processed; nano::observer_set batch_processed; private: From 9a80f294dc7761a1c547d38e09e4a5348f70b363 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 9 Feb 2024 15:19:57 +0100 Subject: [PATCH 081/190] Stats & logs --- nano/core_test/node.cpp | 2 +- nano/lib/stats_enums.hpp | 10 +++++++-- nano/node/blockprocessor.cpp | 41 ++++++++++++++++++++++++++---------- nano/node/blockprocessor.hpp | 1 + 4 files changed, 40 insertions(+), 14 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 0f7410e7f9..34f1de2b12 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2911,7 +2911,7 @@ TEST (node, block_processor_reject_state) send1->signature.bytes[0] ^= 1; ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); node.process_active (send1); - ASSERT_TIMELY_EQ (5s, 1, node.stats.count (nano::stat::type::blockprocessor, nano::stat::detail::bad_signature)); + ASSERT_TIMELY_EQ (5s, 1, node.stats.count (nano::stat::type::blockprocessor_result, nano::stat::detail::bad_signature)); ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 9a726472e7..63c90bddc5 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -36,7 +36,8 @@ enum class type : uint8_t vote_cache, hinting, blockprocessor, - blockprocessor_sources, + blockprocessor_source, + blockprocessor_result, bootstrap_server, active, active_started, @@ -112,7 +113,12 @@ enum class detail : uint8_t representative_mismatch, block_position, - // blockprocessor result + // blockprocessor + process_blocking, + process_blocking_timeout, + force, + + // block source live, bootstrap, bootstrap_legacy, diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 3130da4997..8d762378f3 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -88,14 +88,22 @@ void nano::block_processor::add (std::shared_ptr const & block, blo node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work); return; } + + node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process); + node.logger.debug (nano::log::type::blockprocessor, "Processing block (async): {} (source: {})", block->hash ().to_string (), to_string (source)); + add_impl (block, context{ source }); } std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) { + node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process_blocking); + node.logger.debug (nano::log::type::blockprocessor, "Processing block (blocking): {} (source: {})", block->hash ().to_string (), to_string (source)); + context ctx{ source }; auto future = ctx.get_future (); add_impl (block, std::move (ctx)); + try { auto status = future.wait_for (node.config.block_process_timeout); @@ -107,10 +115,25 @@ std::optional nano::block_processor::add_blocking (std::sh } catch (std::future_error const &) { + node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process_blocking_timeout); + node.logger.error (nano::log::type::blockprocessor, "Timeout processing block: {}", block->hash ().to_string ()); } + return std::nullopt; } +void nano::block_processor::force (std::shared_ptr const & block_a) +{ + node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::force); + node.logger.debug (nano::log::type::blockprocessor, "Forcing block: {}", block_a->hash ().to_string ()); + + { + nano::lock_guard lock{ mutex }; + forced.emplace_back (entry{ block_a, context{ block_source::forced } }); + } + condition.notify_all (); +} + void nano::block_processor::rollback_competitor (store::write_transaction const & transaction, nano::block const & block) { auto hash = block.hash (); @@ -143,15 +166,6 @@ void nano::block_processor::rollback_competitor (store::write_transaction const } } -void nano::block_processor::force (std::shared_ptr const & block_a) -{ - { - nano::lock_guard lock{ mutex }; - forced.emplace_back (entry{ block_a, context{ block_source::forced } }); - } - condition.notify_all (); -} - void nano::block_processor::process_blocks () { nano::unique_lock lock{ mutex }; @@ -304,8 +318,8 @@ nano::process_return nano::block_processor::process_one (store::write_transactio auto const hash = block->hash (); nano::process_return result = node.ledger.process (transaction_a, *block); - node.stats.inc (nano::stat::type::blockprocessor, to_stat_detail (result.code)); - node.stats.inc (nano::stat::type::blockprocessor_sources, to_stat_detail (context.source)); + node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result.code)); + node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source)); node.logger.trace (nano::log::type::blockprocessor, nano::log::detail::block_processed, nano::log::arg{ "result", result.code }, nano::log::arg{ "source", context.source }, @@ -415,6 +429,11 @@ std::unique_ptr nano::collect_container_info (bl return composite; } +std::string_view nano::to_string (nano::block_source source) +{ + return magic_enum::enum_name (source); +} + nano::stat::detail nano::to_stat_detail (nano::block_source type) { auto value = magic_enum::enum_cast (magic_enum::enum_name (type)); diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 97dbb71e63..65bb62e70c 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -31,6 +31,7 @@ enum class block_source forced, }; +std::string_view to_string (nano::block_source); nano::stat::detail to_stat_detail (block_source); /** From 46b00bf828c433eaf6d6aa72fa0ddccfb49310e8 Mon Sep 17 00:00:00 2001 From: gr0vity-dev Date: Sat, 10 Feb 2024 00:05:26 +0100 Subject: [PATCH 082/190] prepare beta reset --- nano/secure/common.cpp | 16 ++++++++-------- rep_weights_beta.bin | Bin 736 -> 0 bytes 2 files changed, 8 insertions(+), 8 deletions(-) delete mode 100644 rep_weights_beta.bin diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 2fe551a788..c9ae8a7d97 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -28,7 +28,7 @@ namespace { char const * dev_private_key_data = "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4"; char const * dev_public_key_data = "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0"; // xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo -char const * beta_public_key_data = "259A43ABDB779E97452E188BA3EB951B41C961D3318CA6B925380F4D99F0577A"; // nano_1betagoxpxwykx4kw86dnhosc8t3s7ix8eeentwkcg1hbpez1outjrcyg4n1 +char const * beta_public_key_data = "259A438A8F9F9226130C84D902C237AF3E57C0981C7D709C288046B110D8C8AC"; // nano_1betagoxpxwykx4kw86dnhosc8t3s7ix8eeentwkcg1hbpez1outjrcyg4n1 char const * live_public_key_data = "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"; // xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3 std::string const test_public_key_data = nano::get_env_or_default ("NANO_TEST_GENESIS_PUB", "45C6FF9D1706D61F0821327752671BDA9F9ED2DA40326B01935AB566FB9E08ED"); // nano_1jg8zygjg3pp5w644emqcbmjqpnzmubfni3kfe1s8pooeuxsw49fdq1mco9j char const * dev_genesis_data = R"%%%({ @@ -42,12 +42,12 @@ char const * dev_genesis_data = R"%%%({ char const * beta_genesis_data = R"%%%({ "type": "open", - "source": "259A43ABDB779E97452E188BA3EB951B41C961D3318CA6B925380F4D99F0577A", - "representative": "nano_1betagoxpxwykx4kw86dnhosc8t3s7ix8eeentwkcg1hbpez1outjrcyg4n1", - "account": "nano_1betagoxpxwykx4kw86dnhosc8t3s7ix8eeentwkcg1hbpez1outjrcyg4n1", - "work": "79d4e27dc873c6f2", - "signature": "4BD7F96F9ED2721BCEE5EAED400EA50AD00524C629AE55E9AFF11220D2C1B00C3D4B3BB770BF67D4F8658023B677F91110193B6C101C2666931F57046A6DB806" - })%%%"; + "source": "259A438A8F9F9226130C84D902C237AF3E57C0981C7D709C288046B110D8C8AC", + "representative": "nano_1betag7az9wk6rbis38s1d35hdsycz1bi95xg4g4j148p6afjk7embcurda4", + "account": "nano_1betag7az9wk6rbis38s1d35hdsycz1bi95xg4g4j148p6afjk7embcurda4", + "work": "e87a3ce39b43b84c", + "signature": "BC588273AC689726D129D3137653FB319B6EE6DB178F97421D11D075B46FD52B6748223C8FF4179399D35CB1A8DF36F759325BD2D3D4504904321FAFB71D7602" + })%%%"; char const * live_genesis_data = R"%%%({ "type": "open", @@ -75,7 +75,7 @@ std::shared_ptr parse_block_from_genesis_data (std::string const & return nano::deserialize_block_json (tree); } -char const * beta_canary_public_key_data = "868C6A9F79D4506E029B378262B91538C5CB26D7C346B63902FFEB365F1C1947"; // nano_33nefchqmo4ifr3bpfw4ecwjcg87semfhit8prwi7zzd8shjr8c9qdxeqmnx +char const * beta_canary_public_key_data = "259a438a8f9f9226130c84d902c237af3e57c0981c7d709c288046b110d8c8ac"; // nano_33nefchqmo4ifr3bpfw4ecwjcg87semfhit8prwi7zzd8shjr8c9qdxeqmnx char const * live_canary_public_key_data = "7CBAF192A3763DAEC9F9BAC1B2CDF665D8369F8400B4BC5AB4BA31C00BAA4404"; // nano_1z7ty8bc8xjxou6zmgp3pd8zesgr8thra17nqjfdbgjjr17tnj16fjntfqfn std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "3BAD2C554ACE05F5E528FBBCE79D51E552C55FA765CCFD89B289C4835DE5F04A"); // nano_1gxf7jcnomi7yqkkjyxwwygo5sckrohtgsgezp6u74g6ifgydw4cajwbk8bf } diff --git a/rep_weights_beta.bin b/rep_weights_beta.bin deleted file mode 100644 index 9657dd075279b710141d26c138e7c8292fb664fd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 736 zcmV<60w4VV000000000000009qOHs&nnSDGcb=C;E*OiW>y;Zp$zjtmjHbCII1f#k z@K<^{nPQ2?h<5!2weXft|NsADsji&(=^IE4xzrGRzT?I@7DzMMn%fdGpA~6>Wh?+VL zp^YqfowNxtnIrBcnm`fe%Fzazm%uDMA1bOcya_ywg6>%)kV1kk>Uhq%d#8_Kmycw^&vt8~Au^g-`j4k!@WLsHa zcWH=98q*#j=LzPXj@$s$MkI0I);Ygul^HyNIroJxP@pjf#QQH+M3N*z>}Sk99((}O zy*crEqGSzD#EI;cw{1=;UC6nts>!mQ$+`5}_uPI5#QQH+M3N*z>}SKwYdiiKPVtKg zC|KW~G+&ot7v!+@$RS{m!14LHdfyyNCp;qu#QQH+M3N*z>|_w|0002Vi^M1tca~uy zu8puVdQ7@1!wQ&-I~%Pw`C@V*8XAiS11`@mdH2=LQHsY+~0#1O>q zJNDZtK*51gVoL$>rGDOUe@(gs0)g%`v`=;j?kfhm17BJr4nw zcMdvUGqa1q*~WjBWsDyK0pW6{$2*vYvYnE!0000bnm}b?MEap^DuovJzMOQXJZz(x zmJZu=eH2Q&4|=@=0OjNs4SE~-y5Kkv0000s64~LF2UQJSEOFc*uMo8BQ8Jw>xR$gdGQj53z8hC^N Sz?a(^^`qtaz>NAp0000FHcylQ From f6a32c98d619dcdc571c2b804c9142b4bb69efe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 9 Feb 2024 18:52:16 +0100 Subject: [PATCH 083/190] Fixes --- nano/node/block_broadcast.cpp | 2 +- nano/node/blockprocessor.cpp | 18 +++++++++--------- nano/node/blockprocessor.hpp | 4 ++-- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index 2fb61e6a17..6cdd673c51 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -36,7 +36,7 @@ void nano::block_broadcast::observe (std::shared_ptr const & block, } else { - if (context.source != nano::block_source::bootstrap) + if (context.source != nano::block_source::bootstrap && context.source != nano::block_source::bootstrap_legacy) { // Block arrived from realtime traffic, do normal gossip. network.flood_block (block, nano::transport::buffer_drop_policy::limiter); diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 8d762378f3..ddca2e8d57 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -222,7 +222,7 @@ bool nano::block_processor::have_blocks () return have_blocks_ready (); } -void nano::block_processor::add_impl (std::shared_ptr block, context ctx) +void nano::block_processor::add_impl (std::shared_ptr const & block, context ctx) { release_assert (ctx.source != nano::block_source::forced); { @@ -237,14 +237,6 @@ auto nano::block_processor::next () -> entry debug_assert (!mutex.try_lock ()); debug_assert (!blocks.empty () || !forced.empty ()); // This should be checked before calling next - if (!blocks.empty ()) - { - entry entry = std::move (blocks.front ()); - release_assert (entry.ctx.source != nano::block_source::forced); - blocks.pop_front (); - return entry; - } - if (!forced.empty ()) { entry entry = std::move (forced.front ()); @@ -253,6 +245,14 @@ auto nano::block_processor::next () -> entry return entry; } + if (!blocks.empty ()) + { + entry entry = std::move (blocks.front ()); + release_assert (entry.ctx.source != nano::block_source::forced); + blocks.pop_front (); + return entry; + } + release_assert (false, "next() called when no blocks are ready"); } diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 65bb62e70c..4d9c222760 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -31,7 +31,7 @@ enum class block_source forced, }; -std::string_view to_string (nano::block_source); +std::string_view to_string (block_source); nano::stat::detail to_stat_detail (block_source); /** @@ -99,7 +99,7 @@ class block_processor final void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); processed_batch_t process_batch (nano::unique_lock &); entry next (); - void add_impl (std::shared_ptr block, context); + void add_impl (std::shared_ptr const & block, context); private: // Dependencies nano::node & node; From a39259bdfdca747ff0f3514d1c5dfd6389398744 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Sun, 11 Feb 2024 18:32:56 +0000 Subject: [PATCH 084/190] Update the beta genesis hash to the new one (#4427) --- systest/node_initialize.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/systest/node_initialize.sh b/systest/node_initialize.sh index bf434f27c3..70e98f3598 100755 --- a/systest/node_initialize.sh +++ b/systest/node_initialize.sh @@ -41,7 +41,7 @@ mkdir -p "$DATADIR/log" #test_initialize_cmd "live" "" "" "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948" test_initialize_cmd "live" "--network" "live" "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948" -test_initialize_cmd "beta" "--network" "beta" "01A92459E69440D5C1088D3B31F4CA678BE944BAB3776C2E6B7665E9BD99BD5A" +test_initialize_cmd "beta" "--network" "beta" "E1227CF974C1455A8B630433D94F3DDBF495EEAC9ADD2481A4A1D90A0D00F488" test_initialize_cmd "test" "--network" "test" "B1D60C0B886B57401EF5A1DAA04340E53726AA6F4D706C085706F31BBD100CEE" # if it got this far then it is a pass From 0b85d1021fdad3f8fe56fb48bb194d02c484d17c Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 13 Feb 2024 11:36:01 +0000 Subject: [PATCH 085/190] Link nano_lib with boost::property_tree which is at least referenced by nano/lib/blocks.hpp (#4432) --- nano/lib/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index e93429ead3..271091dcef 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -124,6 +124,7 @@ target_link_libraries( Boost::dll Boost::multiprecision Boost::program_options + Boost::property_tree Boost::stacktrace) if(NANO_STACKTRACE_BACKTRACE) From 817f346eb3d0dc09c7d050581935cdf1f4d07238 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 13 Feb 2024 14:37:43 +0100 Subject: [PATCH 086/190] Analyze core dumps on test failure (#4430) --- ci/tests/run-core-tests.sh | 6 +--- ci/tests/run-qt-tests.sh | 6 +--- ci/tests/run-rpc-tests.sh | 6 +--- ci/tests/run-tests.sh | 64 +++++++++++++++++++++++++++++++++++++ ci/tests/show-core-dumps.sh | 62 +++++++++++++++++++++++++++++++++++ 5 files changed, 129 insertions(+), 15 deletions(-) create mode 100755 ci/tests/run-tests.sh create mode 100755 ci/tests/show-core-dumps.sh diff --git a/ci/tests/run-core-tests.sh b/ci/tests/run-core-tests.sh index a3e02b70bf..31dd324a3f 100755 --- a/ci/tests/run-core-tests.sh +++ b/ci/tests/run-core-tests.sh @@ -1,8 +1,4 @@ #!/bin/bash set -euo pipefail -source "$(dirname "$BASH_SOURCE")/common.sh" - -BUILD_DIR=${1-${PWD}} - -${BUILD_DIR}/core_test$(get_exec_extension) \ No newline at end of file +$(dirname "$BASH_SOURCE")/run-tests.sh core_test \ No newline at end of file diff --git a/ci/tests/run-qt-tests.sh b/ci/tests/run-qt-tests.sh index 8faa28d43a..c53b77544c 100755 --- a/ci/tests/run-qt-tests.sh +++ b/ci/tests/run-qt-tests.sh @@ -1,10 +1,6 @@ #!/bin/bash set -euo pipefail -source "$(dirname "$BASH_SOURCE")/common.sh" - -BUILD_DIR=${1-${PWD}} - # Alpine doesn't offer an xvfb xvfb_run_() { @@ -20,4 +16,4 @@ xvfb_run_() return ${res} } -xvfb_run_ ${BUILD_DIR}/qt_test$(get_exec_extension) \ No newline at end of file +xvfb_run_ $(dirname "$BASH_SOURCE")/run-tests.sh qt_test \ No newline at end of file diff --git a/ci/tests/run-rpc-tests.sh b/ci/tests/run-rpc-tests.sh index 6b64607d95..91dba35e71 100755 --- a/ci/tests/run-rpc-tests.sh +++ b/ci/tests/run-rpc-tests.sh @@ -1,8 +1,4 @@ #!/bin/bash set -euo pipefail -source "$(dirname "$BASH_SOURCE")/common.sh" - -BUILD_DIR=${1-${PWD}} - -${BUILD_DIR}/rpc_test$(get_exec_extension) \ No newline at end of file +$(dirname "$BASH_SOURCE")/run-tests.sh rpc_test \ No newline at end of file diff --git a/ci/tests/run-tests.sh b/ci/tests/run-tests.sh new file mode 100755 index 0000000000..7ac5594e3c --- /dev/null +++ b/ci/tests/run-tests.sh @@ -0,0 +1,64 @@ +#!/bin/bash +set -uo pipefail + +source "$(dirname "$BASH_SOURCE")/common.sh" + +target=$1 +if [ -z "${target-}" ]; then + echo "Target not specified" + exit 1 +fi + +echo "Running tests for target: ${target}" + +# Enable core dumps +DEFAULT_COREDUMP_DIR="/cores" +case "$(uname -s)" in + Linux*) + # Ensure directory exists and is writable for core dumps + sudo mkdir -p "${DEFAULT_COREDUMP_DIR}" + sudo chmod a+w "${DEFAULT_COREDUMP_DIR}" + # Enable core dumps + ulimit -c unlimited + echo "${DEFAULT_COREDUMP_DIR}/core-%e.%p" | sudo tee /proc/sys/kernel/core_pattern + export COREDUMP_DIR=${DEFAULT_COREDUMP_DIR} + + echo "Core dumps enabled (Linux)" + ;; + Darwin*) + # Ensure directory exists and is writable for core dumps + sudo mkdir -p "${DEFAULT_COREDUMP_DIR}" + sudo chmod a+w "${DEFAULT_COREDUMP_DIR}" + # Enable core dumps + ulimit -c unlimited + # By default, macOS writes core dumps to /cores + export COREDUMP_DIR=${DEFAULT_COREDUMP_DIR} + + echo "Core dumps enabled (macOS)" + ;; + CYGWIN*|MINGW32*|MSYS*|MINGW*) + # TODO: Support core dumps on Windows + echo "Core dumps not supported on Windows" + ;; + *) + echo "Unknown OS" + exit 1 + ;; +esac + +# Run the test +executable=./${target}$(get_exec_extension) +"${executable}" +status=$? + +if [ $status -ne 0 ]; then + echo "::error::Test failed: ${target}" + + # Show core dumps + export EXECUTABLE=${executable} + "$(dirname "$BASH_SOURCE")/show-core-dumps.sh" + + exit $status +else + exit 0 +fi \ No newline at end of file diff --git a/ci/tests/show-core-dumps.sh b/ci/tests/show-core-dumps.sh new file mode 100755 index 0000000000..e8409e83a4 --- /dev/null +++ b/ci/tests/show-core-dumps.sh @@ -0,0 +1,62 @@ +#!/bin/bash +set -uo pipefail + +echo "Analyzing core dumps..." + +if [ -z "${COREDUMP_DIR-}" ]; then + echo "COREDUMP_DIR environment variable is not set." + exit 1 +fi + +if [ -z "${EXECUTABLE-}" ]; then + echo "EXECUTABLE environment variable is not set." + exit 1 +fi + +echo "Core dump location: ${COREDUMP_DIR}" +echo "Executable: ${EXECUTABLE}" + +analyze_core_dump() { + local core_dump=$1 + local executable=$2 + + case "$(uname)" in + Darwin) + # macOS, use lldb + echo "Using lldb for analysis..." + lldb "${executable}" -c "$core_dump" --batch -o "thread backtrace all" -o "quit" + ;; + Linux) + # Linux, use gdb + echo "Using gdb for analysis..." + gdb -quiet -batch -ex "thread apply all bt full" -ex "quit" "${executable}" "$core_dump" + ;; + *) + echo "Unsupported OS." + return 1 + ;; + esac + + # Remove the analyzed core dump file + echo "Removing analyzed core dump: $core_dump" + rm "$core_dump" +} + +# List core dump files +echo "::group::Core dump files" +ls -al "${COREDUMP_DIR}" +echo "::endgroup::" + +# Use a glob pattern to match core dumps +shopt -s nullglob +core_dumps=("${COREDUMP_DIR}"/core*) + +if [ ${#core_dumps[@]} -gt 0 ]; then + for core_dump in "${core_dumps[@]}"; do + echo "::group::Analyzing core dump: $core_dump" + analyze_core_dump "$core_dump" "${EXECUTABLE}" + echo "::endgroup::" + done +else + echo "No core dump file found." +fi From b8249326d139830f033c1ce8aec3b2c7ebd8f24f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 13 Feb 2024 14:37:59 +0100 Subject: [PATCH 087/190] Sanitizer workflow for macOS (#4431) --- .github/workflows/code_sanitizers.yml | 63 +++++++++++++++++++++++++-- 1 file changed, 60 insertions(+), 3 deletions(-) diff --git a/.github/workflows/code_sanitizers.yml b/.github/workflows/code_sanitizers.yml index d98587aa11..3bc0439c61 100644 --- a/.github/workflows/code_sanitizers.yml +++ b/.github/workflows/code_sanitizers.yml @@ -1,6 +1,6 @@ name: Code Sanitizers -on: [push, pull_request, workflow_dispatch] +on: [ push, pull_request, workflow_dispatch ] jobs: linux_sanitizers: @@ -9,8 +9,8 @@ jobs: strategy: fail-fast: false matrix: - BACKEND: [lmdb, rocksdb] - COMPILER: [clang] + BACKEND: [ lmdb, rocksdb ] + COMPILER: [ clang ] SANITIZER: - { name: UBSAN, ignore_errors: false } - { name: ASAN, ignore_errors: true } @@ -58,3 +58,60 @@ jobs: continue-on-error: ${{ env.IGNORE_ERRORS == 'true' }} run: ../ci/tests/show-sanitizer-reports.sh working-directory: build + + + macos_sanitizers: + name: macOS [${{ matrix.SANITIZER.name }}] [${{ matrix.BACKEND }} | ${{ matrix.COMPILER }}] ${{ matrix.SANITIZER.ignore_errors && ' (Errors Ignored)' || '' }} + timeout-minutes: 120 + strategy: + fail-fast: false + matrix: + BACKEND: [ lmdb, rocksdb ] + COMPILER: [ clang ] + SANITIZER: + - { name: UBSAN, ignore_errors: false } + - { name: ASAN, ignore_errors: true } + - { name: TSAN, ignore_errors: true } + runs-on: macos-14 + env: + COMPILER: ${{ matrix.COMPILER }} + BACKEND: ${{ matrix.BACKEND }} + SANITIZER: ${{ matrix.SANITIZER.name }} + IGNORE_ERRORS: ${{ matrix.SANITIZER.ignore_errors }} + TEST_USE_ROCKSDB: ${{ matrix.BACKEND == 'rocksdb' && '1' || '0' }} + DEADLINE_SCALE_FACTOR: ${{ matrix.BACKEND == 'rocksdb' && '2' || '1' }} + ASAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:suppressions=../asan_suppressions + TSAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:suppressions=../tsan_suppressions + UBSAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:print_stacktrace=1 + if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository + steps: + - name: Checkout + uses: actions/checkout@v3 + with: + submodules: "recursive" + + - name: Prepare + run: ci/prepare/macos/prepare.sh + + - name: Build Tests + id: build + run: ci/build-tests.sh + + - name: Core Tests + if: steps.build.outcome == 'success' && (success() || failure()) + continue-on-error: true + run: timeout -sKILL 45m ../ci/tests/run-core-tests.sh + working-directory: build + + - name: RPC Tests + if: steps.build.outcome == 'success' && (success() || failure()) + continue-on-error: true + run: timeout -sKILL 20m ../ci/tests/run-rpc-tests.sh + working-directory: build + + - name: Reports + if: steps.build.outcome == 'success' && (success() || failure()) + continue-on-error: ${{ env.IGNORE_ERRORS == 'true' }} + run: ../ci/tests/show-sanitizer-reports.sh + working-directory: build + From 1b9807af6d46874772ad61051a4b53421bcb1198 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 13 Feb 2024 14:38:34 +0100 Subject: [PATCH 088/190] Use erase_if pattern (#4429) --- nano/node/bootstrap/bootstrap_connections.cpp | 16 ++++------------ nano/node/bootstrap_ascending/peer_scoring.cpp | 14 +++++++------- nano/node/election.cpp | 15 ++++----------- nano/node/telemetry.cpp | 2 +- nano/node/transport/tcp.cpp | 11 ++++------- nano/node/transport/tcp_server.cpp | 13 ++++--------- nano/node/vote_cache.cpp | 15 +++------------ 7 files changed, 27 insertions(+), 59 deletions(-) diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index ccb47c06a6..c843148d25 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -443,18 +443,10 @@ void nano::bootstrap_connections::clear_pulls (uint64_t bootstrap_id_a) { { nano::lock_guard lock{ mutex }; - auto i (pulls.begin ()); - while (i != pulls.end ()) - { - if (i->bootstrap_id == bootstrap_id_a) - { - i = pulls.erase (i); - } - else - { - ++i; - } - } + + erase_if (pulls, [bootstrap_id_a] (auto const & pull) { + return pull.bootstrap_id == bootstrap_id_a; + }); } condition.notify_all (); } diff --git a/nano/node/bootstrap_ascending/peer_scoring.cpp b/nano/node/bootstrap_ascending/peer_scoring.cpp index faeb4fe306..e9b1059662 100644 --- a/nano/node/bootstrap_ascending/peer_scoring.cpp +++ b/nano/node/bootstrap_ascending/peer_scoring.cpp @@ -82,18 +82,18 @@ std::size_t nano::bootstrap_ascending::peer_scoring::size () const void nano::bootstrap_ascending::peer_scoring::timeout () { auto & index = scoring.get (); - for (auto score = index.begin (), n = index.end (); score != n;) - { - if (auto channel = score->shared ()) + + erase_if (index, [] (auto const & score) { + if (auto channel = score.shared ()) { if (channel->alive ()) { - ++score; - continue; + return false; // Keep } } - score = index.erase (score); - } + return true; + }); + for (auto score = scoring.begin (), n = scoring.end (); score != n; ++score) { scoring.modify (score, [] (auto & score_a) { diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 56e86f1b21..d967201d27 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -647,17 +647,10 @@ void nano::election::remove_block (nano::block_hash const & hash_a) { if (auto existing = last_blocks.find (hash_a); existing != last_blocks.end ()) { - for (auto i (last_votes.begin ()); i != last_votes.end ();) - { - if (i->second.hash == hash_a) - { - i = last_votes.erase (i); - } - else - { - ++i; - } - } + erase_if (last_votes, [hash_a] (auto const & entry) { + return entry.second.hash == hash_a; + }); + node.network.publish_filter.clear (existing->second); last_blocks.erase (hash_a); } diff --git a/nano/node/telemetry.cpp b/nano/node/telemetry.cpp index 5260fbfa0c..e1fe6ece98 100644 --- a/nano/node/telemetry.cpp +++ b/nano/node/telemetry.cpp @@ -242,7 +242,7 @@ void nano::telemetry::cleanup () { debug_assert (!mutex.try_lock ()); - nano::erase_if (telemetries, [this] (entry const & entry) { + erase_if (telemetries, [this] (entry const & entry) { // Remove if telemetry data is stale if (!check_timeout (entry)) { diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index c9a6c19dd2..a085dbfc39 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -463,13 +464,9 @@ void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point nano::lock_guard lock{ mutex }; // Remove channels with dead underlying sockets - for (auto it = channels.begin (); it != channels.end (); ++it) - { - if (!it->socket->alive ()) - { - it = channels.erase (it); - } - } + erase_if (channels, [] (auto const & entry) { + return !entry.channel->alive (); + }); auto disconnect_cutoff (channels.get ().lower_bound (cutoff_a)); channels.get ().erase (channels.get ().begin (), disconnect_cutoff); diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index af163701a5..7cfee60243 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -231,15 +231,10 @@ void nano::transport::tcp_listener::on_connection_requeue_delayed (std::function void nano::transport::tcp_listener::evict_dead_connections () { debug_assert (strand.running_in_this_thread ()); - for (auto it = connections_per_address.begin (); it != connections_per_address.end ();) - { - if (it->second.expired ()) - { - it = connections_per_address.erase (it); - continue; - } - ++it; - } + + erase_if (connections_per_address, [] (auto const & entry) { + return entry.second.expired (); + }); } void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr const & socket_a) diff --git a/nano/node/vote_cache.cpp b/nano/node/vote_cache.cpp index 527ea0a097..78c6fa86ff 100644 --- a/nano/node/vote_cache.cpp +++ b/nano/node/vote_cache.cpp @@ -245,18 +245,9 @@ void nano::vote_cache::cleanup () auto const cutoff = std::chrono::steady_clock::now () - config.age_cutoff; - auto it = cache.begin (); - while (it != cache.end ()) - { - if (it->last_vote () < cutoff) - { - it = cache.erase (it); - } - else - { - ++it; - } - } + erase_if (cache, [cutoff] (auto const & entry) { + return entry.last_vote () < cutoff; + }); } std::unique_ptr nano::vote_cache::collect_container_info (const std::string & name) const From 11552cb16f00be09b16fcaa3f9be3a574e817517 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 13 Feb 2024 17:23:24 +0000 Subject: [PATCH 089/190] Move block in to the block_processor::context object. --- nano/node/active_transactions.cpp | 4 +- nano/node/block_broadcast.cpp | 7 ++-- nano/node/block_broadcast.hpp | 2 +- nano/node/blockprocessor.cpp | 46 +++++++++++------------ nano/node/blockprocessor.hpp | 24 +++++------- nano/node/bootstrap_ascending/service.cpp | 6 +-- nano/node/process_live_dispatcher.cpp | 6 +-- 7 files changed, 45 insertions(+), 50 deletions(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 74f1ba4e9f..ed4fb36f6f 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -34,11 +34,11 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi }); // Notify elections about alternative (forked) blocks - block_processor.block_processed.add ([this] (auto const & result, auto const & block, auto const & context) { + block_processor.block_processed.add ([this] (auto const & result, auto const & context) { switch (result.code) { case nano::process_result::fork: - publish (block); + publish (context.block); break; default: break; diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index 6cdd673c51..31cde2956f 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -14,11 +14,11 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) { return; } - block_processor.block_processed.add ([this] (auto const & result, auto const & block, auto const & context) { + block_processor.block_processed.add ([this] (auto const & result, auto const & context) { switch (result.code) { case nano::process_result::progress: - observe (block, context); + observe (context); break; default: break; @@ -26,8 +26,9 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) }); } -void nano::block_broadcast::observe (std::shared_ptr const & block, nano::block_processor::context const & context) +void nano::block_broadcast::observe (nano::block_processor::context const & context) { + auto const & block = context.block; if (context.source == nano::block_source::local) { // Block created on this node diff --git a/nano/node/block_broadcast.hpp b/nano/node/block_broadcast.hpp index 4129ddc415..0f0ee62ff2 100644 --- a/nano/node/block_broadcast.hpp +++ b/nano/node/block_broadcast.hpp @@ -20,7 +20,7 @@ class block_broadcast private: // Block_processor observer - void observe (std::shared_ptr const & block, nano::block_processor::context const &); + void observe (nano::block_processor::context const &); nano::network & network; bool enabled; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index ddca2e8d57..dc8c68eb14 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -12,7 +12,8 @@ * block_processor::context */ -nano::block_processor::context::context (nano::block_source source_a) : +nano::block_processor::context::context (std::shared_ptr block, nano::block_source source_a) : + block{ block }, source{ source_a } { debug_assert (source != nano::block_source::unknown); @@ -39,9 +40,9 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas { batch_processed.add ([this] (auto const & items) { // For every batch item: notify the 'processed' observer. - for (auto const & [result, block, context] : items) + for (auto const & [result, context] : items) { - block_processed.notify (result, block, context); + block_processed.notify (result, context); } }); processing_thread = std::thread ([this] () { @@ -92,7 +93,7 @@ void nano::block_processor::add (std::shared_ptr const & block, blo node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process); node.logger.debug (nano::log::type::blockprocessor, "Processing block (async): {} (source: {})", block->hash ().to_string (), to_string (source)); - add_impl (block, context{ source }); + add_impl (context{ block, source }); } std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) @@ -100,9 +101,9 @@ std::optional nano::block_processor::add_blocking (std::sh node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process_blocking); node.logger.debug (nano::log::type::blockprocessor, "Processing block (blocking): {} (source: {})", block->hash ().to_string (), to_string (source)); - context ctx{ source }; + context ctx{ block, source }; auto future = ctx.get_future (); - add_impl (block, std::move (ctx)); + add_impl (std::move (ctx)); try { @@ -129,7 +130,7 @@ void nano::block_processor::force (std::shared_ptr const & block_a) { nano::lock_guard lock{ mutex }; - forced.emplace_back (entry{ block_a, context{ block_source::forced } }); + forced.emplace_back (context{ block_a, block_source::forced }); } condition.notify_all (); } @@ -180,7 +181,7 @@ void nano::block_processor::process_blocks () debug_assert (!lock.owns_lock ()); // Set results for futures when not holding the lock - for (auto & [result, block, context] : processed) + for (auto & [result, context] : processed) { context.set_result (result); } @@ -222,33 +223,33 @@ bool nano::block_processor::have_blocks () return have_blocks_ready (); } -void nano::block_processor::add_impl (std::shared_ptr const & block, context ctx) +void nano::block_processor::add_impl (context ctx) { release_assert (ctx.source != nano::block_source::forced); { nano::lock_guard guard{ mutex }; - blocks.emplace_back (entry{ block, std::move (ctx) }); + blocks.emplace_back (std::move (ctx)); } condition.notify_all (); } -auto nano::block_processor::next () -> entry +auto nano::block_processor::next () -> context { debug_assert (!mutex.try_lock ()); debug_assert (!blocks.empty () || !forced.empty ()); // This should be checked before calling next if (!forced.empty ()) { - entry entry = std::move (forced.front ()); - release_assert (entry.ctx.source == nano::block_source::forced); + auto entry = std::move (forced.front ()); + release_assert (entry.source == nano::block_source::forced); forced.pop_front (); return entry; } if (!blocks.empty ()) { - entry entry = std::move (blocks.front ()); - release_assert (entry.ctx.source != nano::block_source::forced); + auto entry = std::move (blocks.front ()); + release_assert (entry.source != nano::block_source::forced); blocks.pop_front (); return entry; } @@ -281,10 +282,8 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock node.logger.debug (nano::log::type::blockprocessor, "{} blocks (+ {} forced) in processing queue", blocks.size (), forced.size ()); } - entry entry = next (); - context ctx = std::move (entry.ctx); - auto const block = entry.block; - auto const hash = block->hash (); + auto ctx = next (); + auto const hash = ctx.block->hash (); bool const force = ctx.source == nano::block_source::forced; lock_a.unlock (); @@ -292,13 +291,13 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock if (force) { number_of_forced_processed++; - rollback_competitor (transaction, *block); + rollback_competitor (transaction, *ctx.block); } number_of_blocks_processed++; - auto result = process_one (transaction, block, ctx, force); - processed.emplace_back (result, block, std::move (ctx)); + auto result = process_one (transaction, ctx, force); + processed.emplace_back (result, std::move (ctx)); lock_a.lock (); } @@ -313,8 +312,9 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock return processed; } -nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, std::shared_ptr block, context const & context, bool const forced_a) +nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) { + auto const & block = context.block; auto const hash = block->hash (); nano::process_return result = node.ledger.process (transaction_a, *block); diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 4d9c222760..bae8fbcb78 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -44,8 +44,9 @@ class block_processor final class context { public: - explicit context (block_source); + context (std::shared_ptr block, block_source source); + std::shared_ptr block; block_source const source; std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () }; @@ -60,13 +61,6 @@ class block_processor final friend class block_processor; }; -private: - struct entry - { - std::shared_ptr block; - block_processor::context ctx; - }; - public: block_processor (nano::node &, nano::write_database_queue &); @@ -85,21 +79,21 @@ class block_processor final std::atomic flushing{ false }; public: // Events - using processed_t = std::tuple, context>; + using processed_t = std::tuple; using processed_batch_t = std::deque; // The batch observer feeds the processed observer - nano::observer_set const &, context const &> block_processed; + nano::observer_set block_processed; nano::observer_set batch_processed; private: // Roll back block in the ledger that conflicts with 'block' void rollback_competitor (store::write_transaction const &, nano::block const & block); - nano::process_return process_one (store::write_transaction const &, std::shared_ptr block, context const &, bool forced = false); + nano::process_return process_one (store::write_transaction const &, context const &, bool forced = false); void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); processed_batch_t process_batch (nano::unique_lock &); - entry next (); - void add_impl (std::shared_ptr const & block, context); + context next (); + void add_impl (context); private: // Dependencies nano::node & node; @@ -109,8 +103,8 @@ class block_processor final bool stopped{ false }; bool active{ false }; - std::deque blocks; - std::deque forced; + std::deque blocks; + std::deque forced; std::chrono::steady_clock::time_point next_log; nano::condition_variable condition; diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index d091b64464..14430c0963 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -34,10 +34,10 @@ nano::bootstrap_ascending::service::service (nano::node_config & config_a, nano: nano::lock_guard lock{ mutex }; auto transaction = ledger.store.tx_begin_read (); - for (auto const & [result, block, context] : batch) + for (auto const & [result, context] : batch) { - debug_assert (block != nullptr); - inspect (transaction, result, *block); + debug_assert (context.block != nullptr); + inspect (transaction, result, *context.block); } } diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index daaad17f4f..9dfe769c66 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -20,10 +20,10 @@ void nano::process_live_dispatcher::connect (nano::block_processor & block_proce { block_processor.batch_processed.add ([this] (auto const & batch) { auto const transaction = ledger.store.tx_begin_read (); - for (auto const & [result, block, context] : batch) + for (auto const & [result, context] : batch) { - debug_assert (block != nullptr); - inspect (result, *block, transaction); + debug_assert (context.block != nullptr); + inspect (result, *context.block, transaction); } }); } From 5927a951dd5db02110ab6836f8179d326c0e9ecf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 13 Feb 2024 19:56:46 +0100 Subject: [PATCH 090/190] Constants --- nano/node/blockprocessor.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index bae8fbcb78..5130942c71 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -44,9 +44,9 @@ class block_processor final class context { public: - context (std::shared_ptr block, block_source source); + context (std::shared_ptr block, block_source source); - std::shared_ptr block; + std::shared_ptr const block; block_source const source; std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () }; From dd5a00c1d3359bc27d9a75d369d4e1f7b70f6724 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 14 Feb 2024 12:32:23 +0000 Subject: [PATCH 091/190] Change collect_container_info to be a member of nano::block_processor (#4434) Previously this free function was declared as a friend before it was declared as a function which gave a compiler warning. --- nano/node/blockprocessor.cpp | 12 ++++++------ nano/node/blockprocessor.hpp | 3 +-- nano/node/node.cpp | 2 +- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index dc8c68eb14..a934ef7a97 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -412,20 +412,20 @@ void nano::block_processor::queue_unchecked (store::write_transaction const & tr node.unchecked.trigger (hash_or_account_a); } -std::unique_ptr nano::collect_container_info (block_processor & block_processor, std::string const & name) +std::unique_ptr nano::block_processor::collect_container_info (std::string const & name) { std::size_t blocks_count; std::size_t forced_count; { - nano::lock_guard guard{ block_processor.mutex }; - blocks_count = block_processor.blocks.size (); - forced_count = block_processor.forced.size (); + nano::lock_guard guard{ mutex }; + blocks_count = blocks.size (); + forced_count = forced.size (); } auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "blocks", blocks_count, sizeof (decltype (block_processor.blocks)::value_type) })); - composite->add_component (std::make_unique (container_info{ "forced", forced_count, sizeof (decltype (block_processor.forced)::value_type) })); + composite->add_component (std::make_unique (container_info{ "blocks", blocks_count, sizeof (decltype (blocks)::value_type) })); + composite->add_component (std::make_unique (container_info{ "forced", forced_count, sizeof (decltype (forced)::value_type) })); return composite; } diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 5130942c71..78e55b4e87 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -75,6 +75,7 @@ class block_processor final bool have_blocks_ready (); bool have_blocks (); void process_blocks (); + std::unique_ptr collect_container_info (std::string const & name); std::atomic flushing{ false }; @@ -110,7 +111,5 @@ class block_processor final nano::condition_variable condition; nano::mutex mutex{ mutex_identifier (mutexes::block_processor) }; std::thread processing_thread; - - friend std::unique_ptr collect_container_info (block_processor & block_processor, std::string const & name); }; } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 884a0ae848..641ee89467 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -537,7 +537,7 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (collect_container_info (node.wallets, "wallets")); composite->add_component (collect_container_info (node.vote_processor, "vote_processor")); composite->add_component (collect_container_info (node.rep_crawler, "rep_crawler")); - composite->add_component (collect_container_info (node.block_processor, "block_processor")); + composite->add_component (node.block_processor.collect_container_info ("block_processor")); composite->add_component (collect_container_info (node.online_reps, "online_reps")); composite->add_component (collect_container_info (node.history, "history")); composite->add_component (node.block_uniquer.collect_container_info ("block_uniquer")); From 166b7ce488f76c6a681ae7c2fce0b4f3a6f30c25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 14 Feb 2024 15:07:37 +0100 Subject: [PATCH 092/190] Separate leak sanitizer from ASAN run (#4435) * Do not ignore ASAN errors * Add a separate leak check sanitizer job --- .github/workflows/code_sanitizers.yml | 9 +++++---- ci/build.sh | 3 +++ 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/.github/workflows/code_sanitizers.yml b/.github/workflows/code_sanitizers.yml index 3bc0439c61..c82c31b280 100644 --- a/.github/workflows/code_sanitizers.yml +++ b/.github/workflows/code_sanitizers.yml @@ -13,9 +13,10 @@ jobs: COMPILER: [ clang ] SANITIZER: - { name: UBSAN, ignore_errors: false } - - { name: ASAN, ignore_errors: true } - - { name: ASAN_INT, ignore_errors: true } + - { name: ASAN, ignore_errors: false, leak_check: false } + - { name: ASAN_INT, ignore_errors: true, leak_check: false } - { name: TSAN, ignore_errors: true } + - { name: LEAK, ignore_errors: true, leak_check: true } runs-on: ubuntu-22.04 env: COMPILER: ${{ matrix.COMPILER }} @@ -24,7 +25,7 @@ jobs: IGNORE_ERRORS: ${{ matrix.SANITIZER.ignore_errors }} TEST_USE_ROCKSDB: ${{ matrix.BACKEND == 'rocksdb' && '1' || '0' }} DEADLINE_SCALE_FACTOR: ${{ matrix.BACKEND == 'rocksdb' && '2' || '1' }} - ASAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:suppressions=../asan_suppressions + ASAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:suppressions=../asan_suppressions:detect_leaks=${{ matrix.SANITIZER.leak_check && '1' || '0' }} TSAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:suppressions=../tsan_suppressions UBSAN_OPTIONS: log_exe_name=1:log_path=sanitizer_report:print_stacktrace=1 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository @@ -70,7 +71,7 @@ jobs: COMPILER: [ clang ] SANITIZER: - { name: UBSAN, ignore_errors: false } - - { name: ASAN, ignore_errors: true } + - { name: ASAN, ignore_errors: false } - { name: TSAN, ignore_errors: true } runs-on: macos-14 env: diff --git a/ci/build.sh b/ci/build.sh index 07976992a4..4aabc4d0fb 100755 --- a/ci/build.sh +++ b/ci/build.sh @@ -39,6 +39,9 @@ if [[ ${SANITIZER:-} ]]; then UBSAN) CMAKE_SANITIZER="-DNANO_UBSAN=ON" ;; + LEAK) + CMAKE_SANITIZER="-DNANO_ASAN=ON" + ;; *) echo "Unknown sanitizer: '${SANITIZER}'" exit 1 From c195663d8911507e738860caefe12e150beea34b Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 15 Feb 2024 10:04:01 +0000 Subject: [PATCH 093/190] Remove overload of ledger::amount that was only used in one test and didn't have a meaningful function. (#4436) --- nano/core_test/ledger.cpp | 2 -- nano/secure/ledger.cpp | 7 ------- nano/secure/ledger.hpp | 1 - 3 files changed, 10 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 88f7c6d756..11e5298946 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -47,8 +47,6 @@ TEST (ledger, genesis_balance) auto transaction = store.tx_begin_write (); auto balance = ledger.account_balance (transaction, nano::dev::genesis->account ()); ASSERT_EQ (nano::dev::constants.genesis_amount, balance); - auto amount = ledger.amount (transaction, nano::dev::genesis->account ()); - ASSERT_EQ (nano::dev::constants.genesis_amount, amount); auto info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (info); ASSERT_EQ (1, ledger.cache.account_count); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 0fc1ecd604..b4858da20b 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1192,13 +1192,6 @@ std::optional nano::ledger::account_info (store::transaction return store.account.get (transaction, account); } -// Return amount decrease or increase for block -nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::account const & account_a) -{ - release_assert (account_a == constants.genesis->account ()); - return nano::dev::constants.genesis_amount; -} - nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a) { auto block (store.block.get (transaction_a, hash_a)); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 6cabac2eee..b11781ab94 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -45,7 +45,6 @@ class ledger final * Return account containing hash, returns zero account if account can not be found */ nano::account account_safe (store::transaction const &, nano::block_hash const &) const; - nano::uint128_t amount (store::transaction const &, nano::account const &); nano::uint128_t amount (store::transaction const &, nano::block_hash const &); /** Safe for previous block, but block hash_a must exist */ nano::uint128_t amount_safe (store::transaction const &, nano::block_hash const & hash_a, bool &) const; From 79cd445979e2ab9d8c300d0c58dead5885aa75b4 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 19 Feb 2024 01:34:19 +0000 Subject: [PATCH 094/190] Re-enable unit test active_transactions.confirm_new (#4438) I am renabling this test. It is a trivial test and I can see no reason why it should not work. If it does not work, then we need to find out why. --- nano/core_test/active_transactions.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index cf8676875d..6a80be081d 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1041,10 +1041,7 @@ TEST (active_transactions, confirmation_consistency) } } -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3629 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3634 -TEST (active_transactions, DISABLED_confirm_new) +TEST (active_transactions, confirm_new) { nano::test::system system (1); auto & node1 = *system.nodes[0]; @@ -1063,7 +1060,8 @@ TEST (active_transactions, DISABLED_confirm_new) // Let node2 know about the block ASSERT_TIMELY (5s, node2.block (send->hash ())); // Wait confirmation - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2); } // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache From 0d109e36e07361636c41462343f44accadb3a252 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 19 Feb 2024 11:48:38 +0000 Subject: [PATCH 095/190] Include thread header in threading.hpp (#4439) --- nano/lib/threading.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/nano/lib/threading.hpp b/nano/lib/threading.hpp index 17b74a4cb2..2877d8672a 100644 --- a/nano/lib/threading.hpp +++ b/nano/lib/threading.hpp @@ -4,6 +4,8 @@ #include +#include + namespace nano { namespace thread_attributes From cd770d7a3aa3a1e1dc3f361d2a92f1cb89f162fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 19 Feb 2024 17:48:36 +0100 Subject: [PATCH 096/190] Cleanup unused `broadcast_confirm_req` variants (#4440) --- nano/node/network.cpp | 121 ------------------------------------------ nano/node/network.hpp | 4 -- 2 files changed, 125 deletions(-) diff --git a/nano/node/network.cpp b/nano/node/network.cpp index cc41cd3c3d..4d47533be6 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -226,127 +226,6 @@ void nano::network::send_confirm_req (std::shared_ptr channel_a->send (req); } -void nano::network::broadcast_confirm_req (std::shared_ptr const & block_a) -{ - auto list (std::make_shared>> (node.rep_crawler.representative_endpoints (std::numeric_limits::max ()))); - if (list->empty () || node.rep_crawler.total_weight () < node.online_reps.delta ()) - { - // broadcast request to all peers (with max limit 2 * sqrt (peers count)) - auto peers (node.network.list (std::min (100, node.network.fanout (2.0)))); - list->clear (); - list->insert (list->end (), peers.begin (), peers.end ()); - } - - /* - * In either case (broadcasting to all representatives, or broadcasting to - * all peers because there are not enough connected representatives), - * limit each instance to a single random up-to-32 selection. The invoker - * of "broadcast_confirm_req" will be responsible for calling it again - * if the votes for a block have not arrived in time. - */ - std::size_t const max_endpoints = 32; - nano::random_pool_shuffle (list->begin (), list->end ()); - if (list->size () > max_endpoints) - { - list->erase (list->begin () + max_endpoints, list->end ()); - } - - broadcast_confirm_req_base (block_a, list, 0); -} - -void nano::network::broadcast_confirm_req_base (std::shared_ptr const & block_a, std::shared_ptr>> const & endpoints_a, unsigned delay_a, bool resumption) -{ - std::size_t const max_reps = 10; - auto count (0); - while (!endpoints_a->empty () && count < max_reps) - { - auto channel (endpoints_a->back ()); - send_confirm_req (channel, std::make_pair (block_a->hash (), block_a->root ().as_block_hash ())); - endpoints_a->pop_back (); - count++; - } - if (!endpoints_a->empty ()) - { - delay_a += std::rand () % broadcast_interval_ms; - - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, block_a, endpoints_a, delay_a] () { - if (auto node_l = node_w.lock ()) - { - node_l->network.broadcast_confirm_req_base (block_a, endpoints_a, delay_a, true); - } - }); - } -} - -void nano::network::broadcast_confirm_req_batched_many (std::unordered_map, std::deque>> request_bundle_a, std::function callback_a, unsigned delay_a, bool resumption_a) -{ - for (auto i (request_bundle_a.begin ()), n (request_bundle_a.end ()); i != n;) - { - std::vector> roots_hashes_l; - // Limit max request size hash + root to 7 pairs - while (roots_hashes_l.size () < confirm_req_hashes_max && !i->second.empty ()) - { - // expects ordering by priority, descending - roots_hashes_l.push_back (i->second.front ()); - i->second.pop_front (); - } - nano::confirm_req req{ node.network_params.network, roots_hashes_l }; - i->first->send (req); - if (i->second.empty ()) - { - i = request_bundle_a.erase (i); - } - else - { - ++i; - } - } - if (!request_bundle_a.empty ()) - { - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, request_bundle_a, callback_a, delay_a] () { - if (auto node_l = node_w.lock ()) - { - node_l->network.broadcast_confirm_req_batched_many (request_bundle_a, callback_a, delay_a, true); - } - }); - } - else if (callback_a) - { - callback_a (); - } -} - -void nano::network::broadcast_confirm_req_many (std::deque, std::shared_ptr>>>> requests_a, std::function callback_a, unsigned delay_a) -{ - auto pair_l (requests_a.front ()); - requests_a.pop_front (); - auto block_l (pair_l.first); - // confirm_req to representatives - auto endpoints (pair_l.second); - if (!endpoints->empty ()) - { - broadcast_confirm_req_base (block_l, endpoints, delay_a); - } - /* Continue while blocks remain - Broadcast with random delay between delay_a & 2*delay_a */ - if (!requests_a.empty ()) - { - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, requests_a, callback_a, delay_a] () { - if (auto node_l = node_w.lock ()) - { - node_l->network.broadcast_confirm_req_many (requests_a, callback_a, delay_a); - } - }); - } - else if (callback_a) - { - callback_a (); - } -} - namespace { class network_message_visitor : public nano::message_visitor diff --git a/nano/node/network.hpp b/nano/node/network.hpp index f0785d9441..6ad08806c7 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -96,10 +96,6 @@ class network final void send_keepalive_self (std::shared_ptr const &); void send_node_id_handshake (std::shared_ptr const &, std::optional const & cookie, std::optional const & respond_to); void send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a); - void broadcast_confirm_req (std::shared_ptr const &); - void broadcast_confirm_req_base (std::shared_ptr const &, std::shared_ptr>> const &, unsigned, bool = false); - void broadcast_confirm_req_batched_many (std::unordered_map, std::deque>>, std::function = nullptr, unsigned = broadcast_interval_ms, bool = false); - void broadcast_confirm_req_many (std::deque, std::shared_ptr>>>>, std::function = nullptr, unsigned = broadcast_interval_ms); std::shared_ptr find_node_id (nano::account const &); std::shared_ptr find_channel (nano::endpoint const &); bool not_a_peer (nano::endpoint const &, bool); From 40306635ec11ac12d7cca712c83f8a812079e9de Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 20 Feb 2024 18:09:04 +0000 Subject: [PATCH 097/190] Remove process_return class which only contained process_result. Rename process_result to ledger_code to better indicate its purpose. (#4442) --- nano/core_test/active_transactions.cpp | 46 +- nano/core_test/block_store.cpp | 22 +- nano/core_test/bootstrap.cpp | 74 +-- nano/core_test/bootstrap_ascending.cpp | 10 +- nano/core_test/confirmation_height.cpp | 182 +++---- nano/core_test/conflicts.cpp | 4 +- nano/core_test/election.cpp | 4 +- nano/core_test/election_scheduler.cpp | 8 +- nano/core_test/frontiers_confirmation.cpp | 6 +- nano/core_test/ledger.cpp | 590 +++++++++++----------- nano/core_test/network.cpp | 4 +- nano/core_test/node.cpp | 180 +++---- nano/core_test/processor_service.cpp | 6 +- nano/core_test/request_aggregator.cpp | 30 +- nano/core_test/system.cpp | 4 +- nano/core_test/vote_processor.cpp | 6 +- nano/core_test/voting.cpp | 8 +- nano/core_test/wallet.cpp | 4 +- nano/core_test/wallets.cpp | 10 +- nano/core_test/websocket.cpp | 2 +- nano/node/active_transactions.cpp | 4 +- nano/node/block_broadcast.cpp | 4 +- nano/node/blockprocessor.cpp | 40 +- nano/node/blockprocessor.hpp | 10 +- nano/node/bootstrap/bootstrap.cpp | 2 +- nano/node/bootstrap/bootstrap.hpp | 2 +- nano/node/bootstrap/bootstrap_attempt.cpp | 2 +- nano/node/bootstrap/bootstrap_attempt.hpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 12 +- nano/node/bootstrap_ascending/service.hpp | 2 +- nano/node/epoch_upgrader.cpp | 8 +- nano/node/json_handler.cpp | 28 +- nano/node/node.cpp | 6 +- nano/node/node.hpp | 6 +- nano/node/process_live_dispatcher.cpp | 6 +- nano/node/process_live_dispatcher.hpp | 2 +- nano/node/wallet.cpp | 2 +- nano/qt_test/qt.cpp | 38 +- nano/rpc_test/receivable.cpp | 2 +- nano/rpc_test/rpc.cpp | 144 +++--- nano/secure/common.cpp | 8 +- nano/secure/common.hpp | 11 +- nano/secure/ledger.cpp | 232 ++++----- nano/secure/ledger.hpp | 2 +- nano/slow_test/node.cpp | 62 +-- nano/test_common/ledger.cpp | 2 +- nano/test_common/system.cpp | 4 +- nano/test_common/testutil.cpp | 2 +- 48 files changed, 920 insertions(+), 925 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 6a80be081d..e22cbba546 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -149,7 +149,7 @@ TEST (active_transactions, confirm_frontier) node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); } - ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node2.process (*send)); ASSERT_TIMELY (5s, !node2.active.empty ()); // Save election to check request count afterwards @@ -490,10 +490,10 @@ TEST (active_transactions, inactive_votes_cache_election_start) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*open1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*open2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*open1)); + ASSERT_EQ (nano::block_status::progress, node.process (*open2)); ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count); ASSERT_TRUE (node.active.empty ()); ASSERT_EQ (1, node.ledger.cache.cemented_count); @@ -1093,14 +1093,14 @@ TEST (active_transactions, conflicting_block_vote_existing_election) .build_shared (); auto vote_fork = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); - ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code); + ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ()); ASSERT_TIMELY_EQ (5s, 1, node.active.size ()); // Vote for conflicting block, but the block does not yet exist in the ledger node.active.vote (vote_fork); // Block now gets processed - ASSERT_EQ (nano::process_result::fork, node.process_local (fork).value ().code); + ASSERT_EQ (nano::block_status::fork, node.process_local (fork).value ()); // Election must be confirmed auto election (node.active.election (fork->qualified_root ())); @@ -1163,11 +1163,11 @@ TEST (active_transactions, activate_account_chain) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*send3).code); - ASSERT_EQ (nano::process_result::progress, node.process (*open).code); - ASSERT_EQ (nano::process_result::progress, node.process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*send3)); + ASSERT_EQ (nano::block_status::progress, node.process (*open)); + ASSERT_EQ (nano::block_status::progress, node.process (*receive)); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); ASSERT_TIMELY (5s, node.active.election (send->qualified_root ())); @@ -1246,9 +1246,9 @@ TEST (active_transactions, activate_inactive) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*open).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*open)); auto election = nano::test::start_election (system, node, send2->hash ()); ASSERT_NE (nullptr, election); @@ -1283,7 +1283,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -1295,7 +1295,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (send->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); auto open = builder.make_block () .account (key.pub) @@ -1307,7 +1307,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*open).code); + ASSERT_EQ (nano::block_status::progress, node.process (*open)); ASSERT_TRUE (nano::test::start_elections (system, node, { send, send2, open })); ASSERT_EQ (3, node.active.size ()); @@ -1340,7 +1340,7 @@ TEST (active_transactions, vacancy) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node.active.vacancy_update = [&updated] () { updated = true; }; - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); ASSERT_EQ (1, node.active.vacancy ()); ASSERT_EQ (0, node.active.size ()); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -1381,7 +1381,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send1)); node.process_confirmed (nano::election_status{ send1 }); ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ())); @@ -1396,7 +1396,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); node.process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ())); @@ -1409,7 +1409,7 @@ TEST (active_transactions, fifo) .sign (key0.prv, key0.pub) .work (*system.work.generate (key0.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*receive1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*receive1)); auto receive2 = builder.make_block () .previous (0) @@ -1420,7 +1420,7 @@ TEST (active_transactions, fifo) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*receive2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*receive2)); // Ensure first transaction becomes active node.scheduler.manual.push (receive1); diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 4e622a2beb..fd4c78049d 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1021,7 +1021,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto receive = builder .receive () .previous (send->hash ()) @@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); auto change = builder .change () .previous (receive->hash ()) @@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); auto state_send1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1048,7 +1048,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send1)); auto state_send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1059,7 +1059,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send2)); auto state_send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1070,7 +1070,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send3)); auto state_open = builder .state () .account (key1.pub) @@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_open)); auto epoch = builder .state () .account (key1.pub) @@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_open->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch)); auto epoch_open = builder .state () @@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch_open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch_open)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open)); auto state_receive = builder .state () @@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height) .sign (key2.prv, key2.pub) .work (*pool.generate (epoch_open->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_receive)); auto open = builder .open () .source (state_send3->hash ()) @@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height) .sign (key3.prv, key3.pub) .work (*pool.generate (key3.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); auto block1 (store.block.get (transaction, nano::dev::genesis->hash ())); ASSERT_EQ (block1->sideband ().height, 1); auto block2 (store.block.get (transaction, send->hash ())); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index e73721eacf..1003a01f91 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -69,7 +69,7 @@ TEST (bulk_pull, end_not_owned) open->refresh (); open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); system.nodes[0]->work_generate_blocking (*open); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; @@ -122,7 +122,7 @@ TEST (bulk_pull, ascending_one_hash) .work (0) .build_shared (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -154,7 +154,7 @@ TEST (bulk_pull, ascending_two_account) .work (0) .build_shared (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -189,7 +189,7 @@ TEST (bulk_pull, ascending_end) .work (0) .build_shared (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -249,7 +249,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -257,7 +257,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*receive1)); auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket::endpoint_type_t::server), node0)); auto req = std::make_unique (nano::dev::network_params.network); @@ -375,8 +375,8 @@ TEST (bootstrap_processor, process_state) node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block2); - ASSERT_EQ (nano::process_result::progress, node0->process (*block1).code); - ASSERT_EQ (nano::process_result::progress, node0->process (*block2).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*block1)); + ASSERT_EQ (nano::block_status::progress, node0->process (*block2)); ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); auto node1 = system.make_disconnected_node (std::nullopt, node_flags); @@ -444,7 +444,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); auto open = builder .open () .source (send1->hash ()) @@ -453,7 +453,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*open)); auto send2 = builder .send () .previous (open->hash ()) @@ -462,7 +462,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*send2)); auto receive = builder .receive () .previous (send1->hash ()) @@ -470,7 +470,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*receive)); auto node1 = system.make_disconnected_node (); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -541,7 +541,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // open key account receiving all balance of genesis auto open = builder @@ -552,7 +552,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // send from key to genesis 100 raw auto send2 = builder @@ -563,7 +563,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive the 100 raw on genesis auto receive = builder @@ -573,7 +573,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; @@ -614,7 +614,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // receive all balance on key auto open = builder @@ -625,7 +625,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // 1st bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -643,7 +643,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive the 100 raw from key on genesis auto receive = builder @@ -653,7 +653,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); { auto transaction (node1->store.tx_begin_write ()); @@ -1130,7 +1130,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1141,7 +1141,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); auto open = builder .open () .source (send1->hash ()) @@ -1150,7 +1150,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto receive = builder .state () .account (key.pub) @@ -1161,7 +1161,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive })); @@ -1200,7 +1200,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto open = builder .open () .source (send1->hash ()) @@ -1209,7 +1209,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto send2 = builder .state () .account (key.pub) @@ -1220,7 +1220,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // Start lazy bootstrap with last block in chain known auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1259,7 +1259,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // send Gxrb_ratio raw from genesis to key2 auto send2 = builder @@ -1272,7 +1272,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive send1 on key1 auto open = builder @@ -1283,7 +1283,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // receive send2 on key2 auto state_open = builder @@ -1296,7 +1296,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*state_open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*state_open)); // Start lazy bootstrap with last block in sender chain auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1744,7 +1744,7 @@ TEST (frontier_req, count) .work (0) .build_shared (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto receive1 = builder .make_block () .account (key1.pub) @@ -1756,7 +1756,7 @@ TEST (frontier_req, count) .work (0) .build_shared (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); @@ -1839,7 +1839,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build_shared (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto send2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -1851,7 +1851,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build_shared (); node1->work_generate_blocking (*send2); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); auto receive1 = builder .make_block () .account (key_before_genesis.pub) @@ -1863,7 +1863,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build_shared (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); auto receive2 = builder .make_block () .account (key_after_genesis.pub) @@ -1875,7 +1875,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build_shared (); node1->work_generate_blocking (*receive2); - ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*receive2)); // Request for all accounts (confirmed only) auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index 49b8ed299d..3f8059cdd1 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -171,7 +171,7 @@ TEST (bootstrap_ascending, account_base) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); } @@ -206,8 +206,8 @@ TEST (bootstrap_ascending, account_inductive) // std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl; // std::cerr << "Send1: " << send1->hash ().to_string () << std::endl; // std::cerr << "Send2: " << send2->hash ().to_string () << std::endl; - ASSERT_EQ (nano::process_result::progress, node0.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node0.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (*send2)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (50s, node1.block (send2->hash ()) != nullptr); } @@ -248,8 +248,8 @@ TEST (bootstrap_ascending, trace_base) // std::cerr << "receive1: " << receive1->hash ().to_string () << std::endl; auto & node1 = *system.add_node (); // std::cerr << "--------------- Start ---------------\n"; - ASSERT_EQ (nano::process_result::progress, node0.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node0.process (*receive1).code); + ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (*receive1)); ASSERT_EQ (node1.store.pending.begin (node1.store.tx_begin_read (), nano::pending_key{ key.pub, 0 }), node1.store.pending.end ()); // std::cerr << "node0: " << node0.network.endpoint () << std::endl; // std::cerr << "node1: " << node1.network.endpoint () << std::endl; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index a57657b580..c832b3f2d1 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -199,20 +199,20 @@ TEST (confirmation_height, multiple_accounts) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open3).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); // Check confirmation heights of all the accounts (except genesis) are uninitialized (0), // as we have any just added them to the ledger and not processed any live transactions yet. @@ -669,20 +669,20 @@ TEST (confirmation_height, send_receive_between_2_accounts) // Unpocketed send { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); } add_callback_stats (*node); @@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); } add_callback_stats (*node); @@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_open).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_open)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *change).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_change).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_change)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch1)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive2)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send3).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send3)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive3).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3)); } add_callback_stats (*node); @@ -1117,7 +1117,7 @@ TEST (confirmation_height, conflict_rollback_cemented) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_hash)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*fork1a).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a)); ASSERT_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true)); ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a })); @@ -1269,7 +1269,7 @@ TEST (confirmation_heightDeathTest, modified_chain) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); } uint64_t batch_write_size = 2048; @@ -1290,7 +1290,7 @@ TEST (confirmation_heightDeathTest, modified_chain) ASSERT_DEATH_IF_SUPPORTED (bounded_processor.cement_blocks (scoped_write_guard), ""); } - ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *send)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( @@ -1356,8 +1356,8 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); } uint64_t batch_write_size = 2048; @@ -1379,7 +1379,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) } // Reset conditions and test with the bounded processor - ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *open)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( @@ -1434,8 +1434,8 @@ TEST (confirmation_height, pending_observer_callbacks) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); } add_callback_stats (*node); @@ -1482,7 +1482,7 @@ TEST (confirmation_height, callback_confirmed_history) .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } auto send1 = builder @@ -1586,9 +1586,9 @@ TEST (confirmation_height, dependent_election) .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); } add_callback_stats (*node); @@ -1729,21 +1729,21 @@ TEST (confirmation_height, cemented_gap_below_receive) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); } std::vector observer_order; @@ -1889,21 +1889,21 @@ TEST (confirmation_height, cemented_gap_below_no_cache) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); } // Force some blocks to be cemented so that the cached confirmed info variable is empty @@ -1959,7 +1959,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto const send2 = builder.make_block () .previous (send1->hash ()) @@ -1968,7 +1968,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto const send3 = builder.make_block () .previous (send2->hash ()) @@ -1977,7 +1977,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->process (*send3).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send3)); node->process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ())); @@ -2062,8 +2062,8 @@ TEST (confirmation_height, unbounded_block_cache_iteration) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); } nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded); @@ -2159,11 +2159,11 @@ TEST (confirmation_height, pruned_source) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open2)); } uint64_t batch_write_size = 2; std::atomic stopped{ false }; diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 3a74dfaf70..8ee21c4dba 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -27,7 +27,7 @@ TEST (conflicts, start_stop) .work (0) .build_shared (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); ASSERT_EQ (0, node1.active.size ()); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -56,7 +56,7 @@ TEST (conflicts, add_existing) node1.work_generate_blocking (*send1); // add the block to ledger as an unconfirmed block - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); // wait for send1 to be inserted in the ledger ASSERT_TIMELY (5s, node1.block (send1->hash ())); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 74b520f4fa..52ffa5e8d2 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -224,7 +224,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*open1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); nano::keypair key2; auto const send2 = builder.make_block () @@ -234,7 +234,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4); node_config.peering_port = system.get_available_port (); diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index 2e17c27d50..b13c3af776 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -87,7 +87,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); node.process_confirmed (nano::election_status{ send }); auto receive = builder.make_block () @@ -99,7 +99,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node.process (*receive)); node.process_confirmed (nano::election_status{ receive }); // Second, process two eligible transactions @@ -112,7 +112,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block1)); // There is vacancy so it should be inserted node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -128,7 +128,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (receive->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*block2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block2)); // There is no vacancy so it should stay queued node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ()); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 785e2b0522..3b5c29f376 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -29,7 +29,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::this_thread::sleep_for (std::chrono::seconds (1)); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 11e5298946..fd52883a67 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -77,7 +77,7 @@ TEST (ledger, process_modifies_sideband) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send1)); ASSERT_EQ (send1->sideband ().timestamp, store.block.get (store.tx_begin_read (), send1->hash ())->sideband ().timestamp); } @@ -111,7 +111,7 @@ TEST (ledger, process_send) ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash1)); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, hash1)); - ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*send)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_receivable (transaction, key2.pub)); @@ -135,12 +135,12 @@ TEST (ledger, process_send) nano::block_hash hash2 (open->hash ()); // This was a valid block, it should progress. auto return2 = ledger.process (transaction, *open); - ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (1, open->sideband ().height); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); - ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2)); @@ -212,7 +212,7 @@ TEST (ledger, process_receive) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); nano::keypair key3; auto open = builder .open () @@ -224,7 +224,7 @@ TEST (ledger, process_receive) .build (); nano::block_hash hash2 (open->hash ()); auto return1 = ledger.process (transaction, *open); - ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); @@ -240,7 +240,7 @@ TEST (ledger, process_receive) .work (*pool.generate (hash1)) .build (); nano::block_hash hash3 = send2->hash (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); auto receive = builder .receive () .previous (hash2) @@ -257,7 +257,7 @@ TEST (ledger, process_receive) ASSERT_EQ (25, ledger.amount (transaction, hash4)); ASSERT_TRUE (store.frontier.get (transaction, hash2).is_zero ()); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash4)); - ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (key2.pub, ledger.account (*receive)); ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); @@ -300,7 +300,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); nano::keypair key3; auto open = builder .open () @@ -311,7 +311,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -345,7 +345,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); nano::keypair key3; auto change2 = builder .change () @@ -354,7 +354,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change2)); nano::keypair key2; auto send1 = builder .send () @@ -364,7 +364,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); nano::keypair key4; auto open = builder .open () @@ -374,7 +374,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); auto send2 = builder .send () .previous (send1->hash ()) @@ -383,7 +383,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); auto receive1 = builder .receive () .previous (open->hash ()) @@ -391,7 +391,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (open->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_EQ (1, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 1, ledger.weight (key4.pub)); auto info1 = ledger.account_info (transaction, key2.pub); @@ -435,7 +435,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto receive = builder .receive () .previous (send->hash ()) @@ -443,7 +443,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); ASSERT_FALSE (ledger.rollback (transaction, receive->hash ())); } @@ -467,8 +467,8 @@ TEST (ledger, process_duplicate) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send)); auto open = builder .open () .source (hash1) @@ -477,8 +477,8 @@ TEST (ledger, process_duplicate) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *open)); } TEST (ledger, representative_genesis) @@ -524,7 +524,7 @@ TEST (ledger, representative_change) ASSERT_EQ (0, ledger.amount (transaction, block->hash ())); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); - ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*block)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key2.pub)); @@ -561,7 +561,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); auto block2 = builder .send () .previous (info1->head) @@ -570,7 +570,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); } TEST (ledger, receive_fork) @@ -593,7 +593,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); auto block2 = builder .open () .source (block->hash ()) @@ -602,7 +602,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); auto block3 = builder .change () .previous (block2->hash ()) @@ -610,7 +610,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); auto block4 = builder .send () .previous (block->hash ()) @@ -619,7 +619,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); auto block5 = builder .receive () .previous (block2->hash ()) @@ -627,7 +627,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block5).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block5)); } TEST (ledger, open_fork) @@ -650,7 +650,7 @@ TEST (ledger, open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); auto block2 = builder .open () .source (block->hash ()) @@ -659,7 +659,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); auto block3 = builder .open () .source (block->hash ()) @@ -668,7 +668,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block3)); } TEST (ledger, representation_changes) @@ -701,7 +701,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); nano::keypair key3; auto block2 = builder @@ -712,7 +712,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -724,7 +724,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -735,7 +735,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (200, rep_weights.representation_get (key3.pub)); @@ -747,7 +747,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block4->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block5).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -761,7 +761,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block6).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -776,7 +776,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (key5.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block7).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block7)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -791,7 +791,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block6->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block8).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block8)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -805,7 +805,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (block7->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block9).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block9)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -834,7 +834,7 @@ TEST (ledger, double_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -843,7 +843,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -852,7 +852,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); } TEST (ledger, double_receive) @@ -872,7 +872,7 @@ TEST (ledger, double_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -881,7 +881,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -889,7 +889,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); } TEST (votes, check_signature) @@ -911,7 +911,7 @@ TEST (votes, check_signature) node1.work_generate_blocking (*send1); { auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); } node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -941,7 +941,7 @@ TEST (votes, add_one) .build_shared (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -983,7 +983,7 @@ TEST (votes, add_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1042,7 +1042,7 @@ TEST (votes, add_old) .build_shared (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1100,8 +1100,8 @@ TEST (votes, DISABLED_add_old_different_account) .work (0) .build_shared (); node1.work_generate_blocking (*send2); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, send2 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -1147,7 +1147,7 @@ TEST (votes, add_cooldown) .build_shared (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1190,7 +1190,7 @@ TEST (ledger, successor) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); ASSERT_EQ (*send1, *node1.ledger.successor (transaction, nano::qualified_root (nano::root (0), nano::dev::genesis->hash ()))); ASSERT_EQ (*nano::dev::genesis, *node1.ledger.successor (transaction, nano::dev::genesis->qualified_root ())); ASSERT_EQ (nullptr, node1.ledger.successor (transaction, nano::qualified_root (0))); @@ -1213,9 +1213,9 @@ TEST (ledger, fail_change_old) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto result2 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::old, result2.code); + ASSERT_EQ (nano::block_status::old, result2); } TEST (ledger, fail_change_gap_previous) @@ -1235,7 +1235,7 @@ TEST (ledger, fail_change_gap_previous) .work (*pool.generate (nano::root (1))) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::gap_previous, result1.code); + ASSERT_EQ (nano::block_status::gap_previous, result1); } TEST (ledger, fail_state_bad_signature) @@ -1257,7 +1257,7 @@ TEST (ledger, fail_state_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::bad_signature, result1.code); + ASSERT_EQ (nano::block_status::bad_signature, result1); } TEST (ledger, fail_epoch_bad_signature) @@ -1280,10 +1280,10 @@ TEST (ledger, fail_epoch_bad_signature) .build_shared (); block->signature.bytes[0] ^= 1; auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::bad_signature, result1.code); // Fails epoch signature + ASSERT_EQ (nano::block_status::bad_signature, result1); // Fails epoch signature block->signature.bytes[0] ^= 1; auto result2 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::progress, result2.code); // Succeeds with epoch signature + ASSERT_EQ (nano::block_status::progress, result2); // Succeeds with epoch signature } TEST (ledger, fail_change_bad_signature) @@ -1303,7 +1303,7 @@ TEST (ledger, fail_change_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::bad_signature, result1.code); + ASSERT_EQ (nano::block_status::bad_signature, result1); } TEST (ledger, fail_change_fork) @@ -1323,7 +1323,7 @@ TEST (ledger, fail_change_fork) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); nano::keypair key2; auto block2 = builder .change () @@ -1333,7 +1333,7 @@ TEST (ledger, fail_change_fork) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::fork, result2.code); + ASSERT_EQ (nano::block_status::fork, result2); } TEST (ledger, fail_send_old) @@ -1354,9 +1354,9 @@ TEST (ledger, fail_send_old) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto result2 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::old, result2.code); + ASSERT_EQ (nano::block_status::old, result2); } TEST (ledger, fail_send_gap_previous) @@ -1377,7 +1377,7 @@ TEST (ledger, fail_send_gap_previous) .work (*pool.generate (nano::root (1))) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::gap_previous, result1.code); + ASSERT_EQ (nano::block_status::gap_previous, result1); } TEST (ledger, fail_send_bad_signature) @@ -1398,7 +1398,7 @@ TEST (ledger, fail_send_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block); - ASSERT_EQ (nano::process_result::bad_signature, result1.code); + ASSERT_EQ (nano::block_status::bad_signature, result1); } TEST (ledger, fail_send_negative_spend) @@ -1418,7 +1418,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); nano::keypair key2; auto block2 = builder .send () @@ -1428,7 +1428,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::process_result::negative_spend, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::negative_spend, ledger.process (transaction, *block2)); } TEST (ledger, fail_send_fork) @@ -1448,7 +1448,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); nano::keypair key2; auto block2 = builder .send () @@ -1458,7 +1458,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); } TEST (ledger, fail_open_old) @@ -1478,7 +1478,7 @@ TEST (ledger, fail_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1487,8 +1487,8 @@ TEST (ledger, fail_open_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block2)); } TEST (ledger, fail_open_gap_source) @@ -1509,7 +1509,7 @@ TEST (ledger, fail_open_gap_source) .work (*pool.generate (key1.pub)) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::gap_source, result2.code); + ASSERT_EQ (nano::block_status::gap_source, result2); } TEST (ledger, fail_open_bad_signature) @@ -1529,7 +1529,7 @@ TEST (ledger, fail_open_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1539,7 +1539,7 @@ TEST (ledger, fail_open_bad_signature) .work (*pool.generate (key1.pub)) .build (); block2->signature.clear (); - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *block2)); } TEST (ledger, fail_open_fork_previous) @@ -1559,7 +1559,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1568,7 +1568,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1577,7 +1577,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); auto block4 = builder .open () .source (block2->hash ()) @@ -1586,7 +1586,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block4)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1607,7 +1607,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); nano::keypair badkey; auto block2 = builder .open () @@ -1617,7 +1617,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (badkey.prv, badkey.pub) .work (*pool.generate (badkey.pub)) .build (); - ASSERT_NE (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_NE (nano::block_status::progress, ledger.process (transaction, *block2)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1638,7 +1638,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1647,7 +1647,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1656,7 +1656,7 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); auto block4 = builder .receive () .previous (block3->hash ()) @@ -1664,8 +1664,8 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block4)); } TEST (ledger, fail_receive_gap_source) @@ -1686,7 +1686,7 @@ TEST (ledger, fail_receive_gap_source) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1696,7 +1696,7 @@ TEST (ledger, fail_receive_gap_source) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () .source (block1->hash ()) @@ -1706,7 +1706,7 @@ TEST (ledger, fail_receive_gap_source) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () .previous (block3->hash ()) @@ -1715,7 +1715,7 @@ TEST (ledger, fail_receive_gap_source) .work (*pool.generate (block3->hash ())) .build (); auto result4 = ledger.process (transaction, *block4); - ASSERT_EQ (nano::process_result::gap_source, result4.code); + ASSERT_EQ (nano::block_status::gap_source, result4); } TEST (ledger, fail_receive_overreceive) @@ -1736,7 +1736,7 @@ TEST (ledger, fail_receive_overreceive) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .open () .source (block1->hash ()) @@ -1746,7 +1746,7 @@ TEST (ledger, fail_receive_overreceive) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); auto block3 = builder .receive () .previous (block2->hash ()) @@ -1755,7 +1755,7 @@ TEST (ledger, fail_receive_overreceive) .work (*pool.generate (block2->hash ())) .build (); auto result4 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::unreceivable, result4.code); + ASSERT_EQ (nano::block_status::unreceivable, result4); } TEST (ledger, fail_receive_bad_signature) @@ -1776,7 +1776,7 @@ TEST (ledger, fail_receive_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1786,7 +1786,7 @@ TEST (ledger, fail_receive_bad_signature) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () .source (block1->hash ()) @@ -1796,7 +1796,7 @@ TEST (ledger, fail_receive_bad_signature) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () .previous (block3->hash ()) @@ -1805,7 +1805,7 @@ TEST (ledger, fail_receive_bad_signature) .work (*pool.generate (block3->hash ())) .build (); auto result4 = ledger.process (transaction, *block4); - ASSERT_EQ (nano::process_result::bad_signature, result4.code); + ASSERT_EQ (nano::block_status::bad_signature, result4); } TEST (ledger, fail_receive_gap_previous_opened) @@ -1826,7 +1826,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1836,7 +1836,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () .source (block1->hash ()) @@ -1846,7 +1846,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () .previous (1) @@ -1855,7 +1855,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .work (*pool.generate (nano::root (1))) .build (); auto result4 = ledger.process (transaction, *block4); - ASSERT_EQ (nano::process_result::gap_previous, result4.code); + ASSERT_EQ (nano::block_status::gap_previous, result4); } TEST (ledger, fail_receive_gap_previous_unopened) @@ -1876,7 +1876,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1886,7 +1886,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .receive () .previous (1) @@ -1895,7 +1895,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .work (*pool.generate (nano::root (1))) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::gap_previous, result3.code); + ASSERT_EQ (nano::block_status::gap_previous, result3); } TEST (ledger, fail_receive_fork_previous) @@ -1916,7 +1916,7 @@ TEST (ledger, fail_receive_fork_previous) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1926,7 +1926,7 @@ TEST (ledger, fail_receive_fork_previous) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () .source (block1->hash ()) @@ -1936,7 +1936,7 @@ TEST (ledger, fail_receive_fork_previous) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder .send () @@ -1947,7 +1947,7 @@ TEST (ledger, fail_receive_fork_previous) .work (*pool.generate (block3->hash ())) .build (); auto result4 = ledger.process (transaction, *block4); - ASSERT_EQ (nano::process_result::progress, result4.code); + ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () .previous (block3->hash ()) @@ -1956,7 +1956,7 @@ TEST (ledger, fail_receive_fork_previous) .work (*pool.generate (block3->hash ())) .build (); auto result5 = ledger.process (transaction, *block5); - ASSERT_EQ (nano::process_result::fork, result5.code); + ASSERT_EQ (nano::block_status::fork, result5); } TEST (ledger, fail_receive_received_source) @@ -1977,7 +1977,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); auto result1 = ledger.process (transaction, *block1); - ASSERT_EQ (nano::process_result::progress, result1.code); + ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () .previous (block1->hash ()) @@ -1987,7 +1987,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (block1->hash ())) .build (); auto result2 = ledger.process (transaction, *block2); - ASSERT_EQ (nano::process_result::progress, result2.code); + ASSERT_EQ (nano::block_status::progress, result2); auto block6 = builder .send () .previous (block2->hash ()) @@ -1997,7 +1997,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (block2->hash ())) .build (); auto result6 = ledger.process (transaction, *block6); - ASSERT_EQ (nano::process_result::progress, result6.code); + ASSERT_EQ (nano::block_status::progress, result6); auto block3 = builder .open () .source (block1->hash ()) @@ -2007,7 +2007,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (key1.pub)) .build (); auto result3 = ledger.process (transaction, *block3); - ASSERT_EQ (nano::process_result::progress, result3.code); + ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder .send () @@ -2018,7 +2018,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (block3->hash ())) .build (); auto result4 = ledger.process (transaction, *block4); - ASSERT_EQ (nano::process_result::progress, result4.code); + ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () .previous (block4->hash ()) @@ -2027,7 +2027,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (block4->hash ())) .build (); auto result5 = ledger.process (transaction, *block5); - ASSERT_EQ (nano::process_result::progress, result5.code); + ASSERT_EQ (nano::block_status::progress, result5); auto block7 = builder .receive () .previous (block3->hash ()) @@ -2036,7 +2036,7 @@ TEST (ledger, fail_receive_received_source) .work (*pool.generate (block3->hash ())) .build (); auto result7 = ledger.process (transaction, *block7); - ASSERT_EQ (nano::process_result::fork, result7.code); + ASSERT_EQ (nano::block_status::fork, result7); } TEST (ledger, latest_empty) @@ -2069,7 +2069,7 @@ TEST (ledger, latest_root) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (hash1)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (send->hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub).as_block_hash ()); } @@ -2091,7 +2091,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair key2; auto change = builder @@ -2101,7 +2101,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); nano::keypair key3; auto open = builder .open () @@ -2111,7 +2111,7 @@ TEST (ledger, change_representative_move_representation) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); } @@ -2135,7 +2135,7 @@ TEST (ledger, send_open_receive_rollback) .work (*pool.generate (info1->head)) .build (); auto return1 = ledger.process (transaction, *send1); - ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::block_status::progress, return1); auto send2 = builder .send () .previous (send1->hash ()) @@ -2145,7 +2145,7 @@ TEST (ledger, send_open_receive_rollback) .work (*pool.generate (send1->hash ())) .build (); auto return2 = ledger.process (transaction, *send2); - ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (nano::block_status::progress, return2); nano::keypair key2; auto open = builder .open () @@ -2156,7 +2156,7 @@ TEST (ledger, send_open_receive_rollback) .work (*pool.generate (key1.pub)) .build (); auto return4 = ledger.process (transaction, *open); - ASSERT_EQ (nano::process_result::progress, return4.code); + ASSERT_EQ (nano::block_status::progress, return4); auto receive = builder .receive () .previous (open->hash ()) @@ -2165,7 +2165,7 @@ TEST (ledger, send_open_receive_rollback) .work (*pool.generate (open->hash ())) .build (); auto return5 = ledger.process (transaction, *receive); - ASSERT_EQ (nano::process_result::progress, return5.code); + ASSERT_EQ (nano::block_status::progress, return5); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (nano::dev::genesis_key.pub)); @@ -2178,7 +2178,7 @@ TEST (ledger, send_open_receive_rollback) .work (*pool.generate (send2->hash ())) .build (); auto return6 = ledger.process (transaction, *change1); - ASSERT_EQ (nano::process_result::progress, return6.code); + ASSERT_EQ (nano::block_status::progress, return6); ASSERT_EQ (100, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); @@ -2224,7 +2224,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); } ASSERT_EQ (2, ledger.cache.block_count); { @@ -2245,7 +2245,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); } ASSERT_EQ (3, ledger.cache.block_count); ASSERT_EQ (0, ledger.weight (key2.pub)); @@ -2320,12 +2320,12 @@ TEST (ledger, block_destination_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block5).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block6).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); ASSERT_TRUE (ledger.block_source (transaction, *block1).is_zero ()); @@ -2359,7 +2359,7 @@ TEST (ledger, state_account) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1->hash ())); } @@ -2381,7 +2381,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2404,7 +2404,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2436,7 +2436,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2454,7 +2454,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2487,7 +2487,7 @@ TEST (ledger, state_rep_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); ASSERT_TRUE (store.block.exists (transaction, change1->hash ())); auto change2 = store.block.get (transaction, change1->hash ()); ASSERT_NE (nullptr, change2); @@ -2521,7 +2521,7 @@ TEST (ledger, state_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2540,7 +2540,7 @@ TEST (ledger, state_open) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); ASSERT_TRUE (store.block.exists (transaction, open1->hash ())); auto open2 = store.block.get (transaction, open1->hash ()); @@ -2575,7 +2575,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -2584,7 +2584,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *send2)); } // Make sure old block types can't be inserted after a state block. @@ -2606,7 +2606,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -2614,7 +2614,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); } // Make sure old block types can't be inserted after a state block. @@ -2636,7 +2636,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); nano::keypair rep; auto change1 = builder .change () @@ -2645,7 +2645,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); } TEST (ledger, state_unreceivable_fail) @@ -2664,7 +2664,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2682,7 +2682,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *receive1)); } TEST (ledger, state_receive_bad_amount_fail) @@ -2701,7 +2701,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2719,7 +2719,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *receive1)); } TEST (ledger, state_no_link_amount_fail) @@ -2740,7 +2740,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); nano::keypair rep; auto change1 = builder .state () @@ -2752,7 +2752,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *change1)); } TEST (ledger, state_receive_wrong_account_fail) @@ -2773,7 +2773,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2792,7 +2792,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); } TEST (ledger, state_open_state_fork) @@ -2814,7 +2814,7 @@ TEST (ledger, state_open_state_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .state () .account (destination.pub) @@ -2825,7 +2825,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -2834,7 +2834,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); ASSERT_EQ (open1->root (), open2->root ()); } @@ -2857,7 +2857,7 @@ TEST (ledger, state_state_open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -2866,7 +2866,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto open2 = builder .state () .account (destination.pub) @@ -2877,7 +2877,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); ASSERT_EQ (open1->root (), open2->root ()); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -2901,7 +2901,7 @@ TEST (ledger, state_open_previous_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .state () .account (destination.pub) @@ -2912,7 +2912,7 @@ TEST (ledger, state_open_previous_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (1)) .build (); - ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *open1)); } TEST (ledger, state_open_source_fail) @@ -2934,7 +2934,7 @@ TEST (ledger, state_open_source_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .state () .account (destination.pub) @@ -2945,7 +2945,7 @@ TEST (ledger, state_open_source_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *open1)); } TEST (ledger, state_send_change) @@ -2967,7 +2967,7 @@ TEST (ledger, state_send_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3000,7 +3000,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3019,7 +3019,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -3053,7 +3053,7 @@ TEST (ledger, state_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -3062,7 +3062,7 @@ TEST (ledger, state_open_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3087,7 +3087,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3098,7 +3098,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); auto open1 = builder .open () .source (send1->hash ()) @@ -3107,7 +3107,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -3115,7 +3115,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3139,7 +3139,7 @@ TEST (ledger, state_rollback_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3177,7 +3177,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto receive1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3188,7 +3188,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); @@ -3220,7 +3220,7 @@ TEST (ledger, state_rollback_received_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto receive1 = builder .state () .account (key.pub) @@ -3231,7 +3231,7 @@ TEST (ledger, state_rollback_received_send) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); @@ -3263,7 +3263,7 @@ TEST (ledger, state_rep_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); ASSERT_FALSE (store.block.exists (transaction, change1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3290,7 +3290,7 @@ TEST (ledger, state_open_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto open1 = builder .state () .account (destination.pub) @@ -3301,7 +3301,7 @@ TEST (ledger, state_open_rollback) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); ASSERT_FALSE (store.block.exists (transaction, open1->hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); @@ -3332,7 +3332,7 @@ TEST (ledger, state_send_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3359,7 +3359,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); nano::keypair rep; auto receive1 = builder .state () @@ -3371,7 +3371,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3399,7 +3399,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); ASSERT_FALSE (epoch1->sideband ().details.is_send); ASSERT_FALSE (epoch1->sideband ().details.is_receive); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); @@ -3415,7 +3415,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *epoch2).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch2)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3423,7 +3423,7 @@ TEST (ledger, epoch_blocks_v1_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3439,7 +3439,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3450,7 +3450,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (send1->sideband ().details.is_send); ASSERT_FALSE (send1->sideband ().details.is_receive); ASSERT_FALSE (send1->sideband ().details.is_epoch); @@ -3464,7 +3464,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); auto epoch3 = builder .state () .account (destination.pub) @@ -3475,7 +3475,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, *epoch3).code); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch3)); auto epoch4 = builder .state () .account (destination.pub) @@ -3486,7 +3486,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); ASSERT_FALSE (epoch4->sideband ().details.is_send); ASSERT_FALSE (epoch4->sideband ().details.is_receive); ASSERT_TRUE (epoch4->sideband ().details.is_epoch); @@ -3499,7 +3499,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3510,7 +3510,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch4->hash ())); @@ -3543,7 +3543,7 @@ TEST (ledger, epoch_blocks_v2_general) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); // Trying to upgrade from epoch 0 to epoch 2. It is a requirement epoch upgrades are sequential unless the account is unopened - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch1)); // Set it to the first epoch and it should now succeed epoch1 = builder .state () @@ -3555,7 +3555,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (epoch1->work) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks auto epoch2 = builder @@ -3568,7 +3568,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); ASSERT_EQ (nano::epoch::epoch_2, epoch2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch2->sideband ().source_epoch); // Not used for epoch blocks auto epoch3 = builder @@ -3581,7 +3581,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *epoch3).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch3)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_2); @@ -3589,7 +3589,7 @@ TEST (ledger, epoch_blocks_v2_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3600,7 +3600,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3611,7 +3611,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_EQ (nano::epoch::epoch_1, send1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1->sideband ().source_epoch); // Not used for send blocks auto open1 = builder @@ -3622,7 +3622,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); auto epoch4 = builder .state () .account (destination.pub) @@ -3633,7 +3633,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); ASSERT_EQ (nano::epoch::epoch_1, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks auto epoch5 = builder @@ -3646,7 +3646,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, *epoch5).code); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch5)); auto epoch6 = builder .state () .account (destination.pub) @@ -3657,7 +3657,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch6).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch6)); ASSERT_EQ (nano::epoch::epoch_2, epoch6->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch6->sideband ().source_epoch); // Not used for epoch blocks auto receive1 = builder @@ -3667,7 +3667,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3678,7 +3678,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch6->hash ())); @@ -3707,7 +3707,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3718,7 +3718,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3729,7 +3729,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_EQ (nano::epoch::epoch_1, send2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send2->sideband ().source_epoch); // Not used for send blocks auto open1 = builder @@ -3740,7 +3740,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().source_epoch); auto receive1 = builder @@ -3750,7 +3750,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3761,7 +3761,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); auto destination_info = ledger.account_info (transaction, destination.pub); @@ -3776,7 +3776,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::dev::genesis_key.pub, pending_send2->source); ASSERT_EQ (nano::Gxrb_ratio, pending_send2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, pending_send2->epoch); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3793,7 +3793,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (receive2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); auto open2 = builder .open () .source (send3->hash ()) @@ -3802,7 +3802,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination2.prv, destination2.pub) .work (*pool.generate (destination2.pub)) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open2)); // Upgrade to epoch 2 and send to destination. Try to create an open block from an epoch 2 source block. nano::keypair destination3; auto epoch2 = builder @@ -3815,7 +3815,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); auto send4 = builder .state () .account (nano::dev::genesis->account ()) @@ -3826,7 +3826,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send4)); auto open3 = builder .open () .source (send4->hash ()) @@ -3835,7 +3835,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination3.prv, destination3.pub) .work (*pool.generate (destination3.pub)) .build (); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open3).code); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open3)); // Send it to an epoch 1 account auto send5 = builder .state () @@ -3847,7 +3847,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send4->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send5).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send5)); destination_info = ledger.account_info (transaction, destination.pub); ASSERT_TRUE (destination_info); ASSERT_EQ (destination_info->epoch (), nano::epoch::epoch_1); @@ -3861,7 +3861,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive3)); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3879,7 +3879,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send5->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send6).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send6)); auto epoch4 = builder .state () .account (destination4.pub) @@ -3890,7 +3890,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination4.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch4).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); ASSERT_EQ (nano::epoch::epoch_2, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); @@ -3913,7 +3913,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3924,7 +3924,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch1)); auto epoch2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3935,7 +3935,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); auto epoch3 = builder .state () .account (nano::dev::genesis->account ()) @@ -3946,7 +3946,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch3)); ASSERT_EQ (nano::epoch::epoch_1, epoch3->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch3->sideband ().source_epoch); // Not used for epoch state blocks auto epoch4 = builder @@ -3959,7 +3959,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch2).code); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); } TEST (ledger, successor_epoch) @@ -4017,11 +4017,11 @@ TEST (ledger, successor_epoch) .work (*pool.generate (open->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *change).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *epoch_open).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *epoch_open)); ASSERT_EQ (*change, *node1.ledger.successor (transaction, change->qualified_root ())); ASSERT_EQ (*epoch_open, *node1.ledger.successor (transaction, epoch_open->qualified_root ())); ASSERT_EQ (nano::epoch::epoch_1, epoch_open->sideband ().details.epoch); @@ -4045,7 +4045,7 @@ TEST (ledger, epoch_open_pending) .work (*pool.generate (key1.pub)) .build_shared (); auto process_result = node1.ledger.process (node1.store.tx_begin_write (), *epoch_open); - ASSERT_EQ (nano::process_result::gap_epoch_open_pending, process_result.code); + ASSERT_EQ (nano::block_status::gap_epoch_open_pending, process_result); node1.block_processor.add (epoch_open); // Waits for the block to get saved in the database ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); @@ -4135,10 +4135,10 @@ TEST (ledger, block_hash_account_conflict) node1.work_generate_blocking (*receive1); node1.work_generate_blocking (*send2); node1.work_generate_blocking (*open_epoch1); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node1.process (*receive1).code); - ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); - ASSERT_EQ (nano::process_result::progress, node1.process (*open_epoch1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (*open_epoch1)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, receive1, send2, open_epoch1 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -4212,7 +4212,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *send1)); ASSERT_FALSE (ledger.could_fit (transaction, *send2)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); @@ -4238,12 +4238,12 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *open1)); ASSERT_FALSE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); ASSERT_TRUE (ledger.could_fit (transaction, *send2)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); // Create another send to receive @@ -4277,7 +4277,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *receive1)); ASSERT_FALSE (ledger.could_fit (transaction, *receive2)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); // Test epoch (state) @@ -4292,11 +4292,11 @@ TEST (ledger, could_fit) .work (*pool.generate (receive1->hash ())) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); } @@ -4588,7 +4588,7 @@ TEST (ledger, confirmation_height_not_updated) ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); @@ -4600,7 +4600,7 @@ TEST (ledger, confirmation_height_not_updated) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_TRUE (store.confirmation_height.get (transaction, key.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); @@ -4621,7 +4621,7 @@ TEST (ledger, zero_rep) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block1)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); auto block2 = builder.state () @@ -4633,7 +4633,7 @@ TEST (ledger, zero_rep) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block2)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0)); } @@ -4656,9 +4656,9 @@ TEST (ledger, work_validation) { block_a.block_work_set (block_a.block_work () + 1); } - EXPECT_EQ (nano::process_result::insufficient_work, ledger.process (store.tx_begin_write (), block_a).code); + EXPECT_EQ (nano::block_status::insufficient_work, ledger.process (store.tx_begin_write (), block_a)); block_a.block_work_set (*pool.generate (block_a.root (), threshold)); - EXPECT_EQ (nano::process_result::progress, ledger.process (store.tx_begin_write (), block_a).code); + EXPECT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), block_a)); }; std::error_code ec; @@ -4746,7 +4746,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) @@ -4757,7 +4757,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2)); auto receive1 = builder.state () .account (key1.pub) @@ -4768,7 +4768,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4784,7 +4784,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (receive1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); ASSERT_TRUE (ledger.store.confirmation_height.get (transaction, key1.pub, height)); height.height += 1; @@ -4818,7 +4818,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) .previous (send1->hash ()) @@ -4828,7 +4828,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height = 3; @@ -4868,7 +4868,7 @@ TEST (ledger, block_confirmed) .build (); // Must be safe against non-existing blocks ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4927,7 +4927,7 @@ TEST (ledger, cache) .build (); { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); } ++block_count; @@ -4937,7 +4937,7 @@ TEST (ledger, cache) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); } ++block_count; @@ -5008,7 +5008,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send1_stored (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send1_stored); @@ -5024,7 +5024,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5050,7 +5050,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); auto receive1_stored (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive1_stored); @@ -5096,7 +5096,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (last_hash)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_TRUE (store->block.exists (transaction, send->hash ())); auto receive = builder .state () @@ -5108,7 +5108,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); ASSERT_TRUE (store->block.exists (transaction, receive->hash ())); last_hash = receive->hash (); } @@ -5147,7 +5147,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -5158,7 +5158,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto send2 = builder .state () @@ -5170,7 +5170,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5195,7 +5195,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5207,7 +5207,7 @@ TEST (ledger, pruning_source_rollback) ASSERT_EQ (nano::Gxrb_ratio, info2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2->epoch); // Process receive block again - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5233,7 +5233,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); nano::keypair key1; auto send2 = builder @@ -5244,7 +5244,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); auto send3 = builder @@ -5255,7 +5255,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); ASSERT_TRUE (store->block.exists (transaction, send3->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3->hash ()))); // Pruning action @@ -5283,7 +5283,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5295,7 +5295,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info3->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3->epoch); // Process receive block again - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5308,7 +5308,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5320,7 +5320,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info4->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4->epoch); // Process open block again - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5348,7 +5348,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_EQ (0, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); // Pruning action for latest block (not valid action) @@ -5356,7 +5356,7 @@ TEST (ledger, pruning_process_error) ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); ASSERT_TRUE (store->pruned.exists (transaction, send1->hash ())); // Attempt to process pruned block again - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send1)); // Attept to process new block after pruned auto send2 = builder .state () @@ -5368,7 +5368,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *send2)); ASSERT_EQ (1, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); } @@ -5394,7 +5394,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto receive1 = builder .receive () @@ -5403,7 +5403,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); auto change1 = builder .change () .previous (receive1->hash ()) @@ -5411,7 +5411,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); auto send2 = builder .send () .previous (change1->hash ()) @@ -5420,7 +5420,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); auto open1 = builder .open () .source (send2->hash ()) @@ -5429,7 +5429,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); auto send3 = builder .send () .previous (open1->hash ()) @@ -5438,7 +5438,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); // Pruning action ASSERT_EQ (3, ledger.pruning_action (transaction, change1->hash (), 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, open1->hash (), 1)); @@ -5481,7 +5481,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5493,7 +5493,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5542,7 +5542,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5554,7 +5554,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5680,7 +5680,7 @@ TEST (ledger, unconfirmed_frontiers) .work (*pool.generate (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (store.tx_begin_write (), *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send)); unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index acdc87d43f..98b8fedaa1 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -366,7 +366,7 @@ TEST (receivable_processor, confirm_insufficient_pos) .work (0) .build_shared (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; auto vote = nano::test::make_vote (key1, { block1 }, 0, 0); @@ -389,7 +389,7 @@ TEST (receivable_processor, confirm_sufficient_pos) .work (0) .build_shared (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 34f1de2b12..4faa66e0bb 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -618,7 +618,7 @@ TEST (node, fork_publish_inactive) std::shared_ptr election; ASSERT_TIMELY (5s, election = node.active.election (send1->qualified_root ())); - ASSERT_EQ (nano::process_result::fork, node.process_local (send2).value ().code); + ASSERT_EQ (nano::block_status::fork, node.process_local (send2).value ()); ASSERT_TIMELY_EQ (5s, election->blocks ().size (), 2); @@ -771,10 +771,10 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); // Node2 has two blocks that will be rolled back by node1's vote - ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code); - ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3).code); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1 auto election = nano::test::start_election (system, node2, send2->hash ()); @@ -821,8 +821,8 @@ TEST (node, fork_bootstrap_flip) .work (*system0.work.generate (latest)) .build_shared (); // Insert but don't rebroadcast, simulating settled blocks - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); - ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block auto again (true); @@ -1033,9 +1033,9 @@ TEST (node, fork_no_vote_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node2.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node3.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node2.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node3.process (*send1)); auto key2 (system.wallet (2)->deterministic_insert ()); auto send2 = nano::send_block_builder () .previous (block->hash ()) @@ -1181,9 +1181,9 @@ TEST (node, DISABLED_fork_stale) node1.work_generate_blocking (*send2); { auto transaction1 (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction1, *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, *send1)); auto transaction2 (node2.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node2.ledger.process (transaction2, *send2).code); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, *send2)); } node1.process_active (send1); node1.process_active (send2); @@ -1262,24 +1262,24 @@ TEST (node, DISABLED_broadcast_elected) .sign (rep_other.prv, rep_other.pub) .work (*system.work.generate (rep_other.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_big).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_big).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_big).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_big).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_big).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_big).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_small).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_small).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_small).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_small).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_small).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_small).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_other).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_other).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_other).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_other).code); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_other).code); - ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_other).code); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_big)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_big)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_big)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_big)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_big)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_big)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_small)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_small)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_small)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_small)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_small)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_small)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_other)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_other)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_other)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_other)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_other)); + ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_other)); } // Confirm blocks to allow voting for (auto & node : system.nodes) @@ -1351,8 +1351,8 @@ TEST (node, rep_self_vote) .sign (rep_big.prv, rep_big.pub) .work (*system.work.generate (rep_big.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node0->process (fund_big).code); - ASSERT_EQ (nano::process_result::progress, node0->process (open_big).code); + ASSERT_EQ (nano::block_status::progress, node0->process (fund_big)); + ASSERT_EQ (nano::block_status::progress, node0->process (open_big)); // Confirm both blocks, allowing voting on the upcoming block node0->start_election (node0->block (open_big.hash ())); std::shared_ptr election; @@ -1369,7 +1369,7 @@ TEST (node, rep_self_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (fund_big.hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*block0).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*block0)); auto & active = node0->active; auto & scheduler = node0->scheduler; scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ()); @@ -1403,7 +1403,7 @@ TEST (node, DISABLED_bootstrap_no_publish) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *send0).code); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *send0)); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -1444,7 +1444,7 @@ TEST (node, DISABLED_bootstrap_bulk_push) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); @@ -1497,8 +1497,8 @@ TEST (node, bootstrap_fork_open) .work (*system.work.generate (key0.pub)) .build (); // Both know about send0 - ASSERT_EQ (nano::process_result::progress, node0->process (send0).code); - ASSERT_EQ (nano::process_result::progress, node1->process (send0).code); + ASSERT_EQ (nano::block_status::progress, node0->process (send0)); + ASSERT_EQ (nano::block_status::progress, node1->process (send0)); // Confirm send0 to allow starting and voting on the following blocks for (auto node : system.nodes) { @@ -1511,8 +1511,8 @@ TEST (node, bootstrap_fork_open) } ASSERT_TIMELY (3s, node0->block_confirmed (send0.hash ())); // They disagree about open0/open1 - ASSERT_EQ (nano::process_result::progress, node0->process (open0).code); - ASSERT_EQ (nano::process_result::progress, node1->process (open1).code); + ASSERT_EQ (nano::block_status::progress, node0->process (open0)); + ASSERT_EQ (nano::block_status::progress, node1->process (open1)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0.hash ())); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); @@ -1540,7 +1540,7 @@ TEST (node, bootstrap_confirm_frontiers) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code); + ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); // each system only has one node, so there should be no bootstrapping going on ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); @@ -1598,7 +1598,7 @@ TEST (node, unconfirmed_send) .sign (key2.prv, key2.pub) .work (*system.work.generate (recv1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node2.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node2.process (*send2)); auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio); ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ())); @@ -1698,10 +1698,10 @@ TEST (node, rep_weight) .build (); { auto transaction = node.store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block1).code); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block2).code); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block3).code); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block4)); } ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); @@ -1788,10 +1788,10 @@ TEST (node, rep_remove) .build (); { auto transaction = searching_node.store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *send_to_rep1).code); - ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *receive_rep1).code); - ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *send_to_rep2).code); - ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *receive_rep2).code); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep2)); } // Create channel for Rep1 @@ -2127,7 +2127,7 @@ TEST (node, confirm_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ()); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ())); auto election = node1.active.election (send1->qualified_root ()); @@ -2174,8 +2174,8 @@ TEST (node, local_votes_cache) .build_shared (); { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send2)); } // Confirm blocks to allow voting node.start_election (send2); @@ -2205,7 +2205,7 @@ TEST (node, local_votes_cache) // Max cache { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send3)); } nano::confirm_req message3{ nano::dev::network_params.network, send3->hash (), send3->root () }; for (auto i (0); i < 100; ++i) @@ -2243,7 +2243,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -2255,7 +2255,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -2265,7 +2265,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; nano::confirm_req message{ nano::dev::network_params.network, batch }; auto channel = std::make_shared (node); @@ -2328,7 +2328,7 @@ TEST (node, local_votes_cache_generate_new_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send1)); // One of the hashes is cached std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes }; @@ -2376,7 +2376,7 @@ TEST (node, local_votes_cache_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); // Cache vote auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -2468,7 +2468,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); blocks.push_back (block); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); for (auto i = 2; i < 200; ++i) { auto block = builder.make_block () @@ -2479,7 +2479,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (blocks.back ()->hash ())) .build_shared (); blocks.push_back (block); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); } // Confirming last block will confirm whole chain and allow us to generate votes for those blocks later @@ -3443,8 +3443,8 @@ TEST (node, rollback_gap_source) .sign (key.prv, key.pub) .build_shared (); // Set 'node' up with losing block 'fork1a' - ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*fork1a).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*fork1a)); // Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block ASSERT_EQ (nullptr, node.block (send2->hash ())); node.block_processor.force (fork1b); @@ -3457,7 +3457,7 @@ TEST (node, rollback_gap_source) node.process_active (fork1a); ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr); // With send2 block in ledger election can start again to remove fork block - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); node.block_processor.force (fork1b); // Wait for new rollback ASSERT_TIMELY_EQ (5s, node.stats.count (nano::stat::type::rollback, nano::stat::detail::open), 2); @@ -3601,19 +3601,19 @@ TEST (node, dependency_graph) .work (*system.work.generate (key3_receive->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node.process (*gen_send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key1_open).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key1_send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*gen_receive).code); - ASSERT_EQ (nano::process_result::progress, node.process (*gen_send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key2_open).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key2_send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key3_open).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key2_send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key1_receive).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key1_send2).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key3_receive).code); - ASSERT_EQ (nano::process_result::progress, node.process (*key3_epoch).code); + ASSERT_EQ (nano::block_status::progress, node.process (*gen_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*key1_open)); + ASSERT_EQ (nano::block_status::progress, node.process (*key1_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*gen_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (*gen_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*key2_open)); + ASSERT_EQ (nano::block_status::progress, node.process (*key2_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*key3_open)); + ASSERT_EQ (nano::block_status::progress, node.process (*key2_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*key1_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (*key1_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (*key3_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (*key3_epoch)); ASSERT_TRUE (node.active.empty ()); // Hash -> Ancestors @@ -3805,19 +3805,19 @@ TEST (node, dependency_graph_frontier) for (auto const & node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_epoch).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_epoch)); } // node1 can vote, but only on the first block @@ -3931,7 +3931,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NE (nullptr, election_open); // Confirm one of the dependents of the receive but not the other, to ensure both have to be confirmed to start an election on processing - ASSERT_EQ (nano::process_result::progress, node.process (*receive).code); + ASSERT_EQ (nano::block_status::progress, node.process (*receive)); ASSERT_FALSE (node.active.active (receive->qualified_root ())); election_open->force_confirm (); ASSERT_TIMELY (5s, node.block_confirmed (open->hash ())); @@ -3944,7 +3944,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); // Processing a fork will also not start an election - ASSERT_EQ (nano::process_result::fork, node.process (*fork).code); + ASSERT_EQ (nano::block_status::fork, node.process (*fork)); node.process_local (fork); ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 406e2ed47d..d4fc701452 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -32,7 +32,7 @@ TEST (processor_service, bad_send_signature) .work (*pool.generate (info1->head)) .build (); send->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *send)); } TEST (processor_service, bad_receive_signature) @@ -57,7 +57,7 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info2); auto receive = builder @@ -68,5 +68,5 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (hash1)) .build (); receive->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *receive)); } diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 9eb4a73159..93b3edc5b4 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -36,7 +36,7 @@ TEST (request_aggregator, one) ASSERT_TIMELY (3s, node.aggregator.empty ()); // Not yet in the ledger ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); // In the ledger but no vote generated yet @@ -73,7 +73,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -85,7 +85,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -95,7 +95,7 @@ TEST (request_aggregator, one_update) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); auto client = std::make_shared (node); @@ -139,7 +139,7 @@ TEST (request_aggregator, two) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = builder.make_block () @@ -160,8 +160,8 @@ TEST (request_aggregator, two) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (receive1->hash (), receive1->root ()); @@ -218,7 +218,7 @@ TEST (request_aggregator, two_endpoints) .build_shared (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); auto dummy_channel1 = std::make_shared (node1, node1); auto dummy_channel2 = std::make_shared (node2, node2); ASSERT_NE (nano::transport::map_endpoint_to_v6 (dummy_channel1->get_endpoint ()), nano::transport::map_endpoint_to_v6 (dummy_channel2->get_endpoint ())); @@ -279,7 +279,7 @@ TEST (request_aggregator, split) .build ()); auto const & block = blocks.back (); previous = block->hash (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *block).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *block)); request.emplace_back (block->hash (), block->root ()); } // Confirm all blocks @@ -325,7 +325,7 @@ TEST (request_aggregator, channel_lifetime) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); { @@ -356,7 +356,7 @@ TEST (request_aggregator, channel_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); std::weak_ptr channel1_w; @@ -396,7 +396,7 @@ TEST (request_aggregator, channel_max_queue) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -424,7 +424,7 @@ TEST (request_aggregator, unique) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -464,8 +464,8 @@ TEST (request_aggregator, cannot_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); - ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (*send2)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2)); diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 41e7f9c841..e40916700b 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing) .work (0) .build_shared (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); auto info2 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub); @@ -111,7 +111,7 @@ TEST (system, DISABLED_generate_send_new) .work (0) .build_shared (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); std::vector accounts; diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index bd33093ac3..c19a895347 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -204,7 +204,7 @@ TEST (vote_processor, no_broadcast_local) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (ec); ASSERT_FALSE (ec); - ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code); + ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ()); ASSERT_TIMELY (10s, !node.active.empty ()); ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub)); // Insert account in wallet. Votes on node are not enabled. @@ -257,7 +257,7 @@ TEST (vote_processor, local_broadcast_without_a_representative) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (ec); ASSERT_FALSE (ec); - ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code); + ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ()); ASSERT_TIMELY (10s, !node.active.empty ()); ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev::genesis_key.pub)); node.start_election (send); @@ -305,7 +305,7 @@ TEST (vote_processor, no_broadcast_local_with_a_principal_representative) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (ec); ASSERT_FALSE (ec); - ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code); + ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ()); ASSERT_TIMELY (10s, !node.active.empty ()); ASSERT_EQ (nano::dev::constants.genesis_amount - 2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub)); // Insert account in wallet. Votes on node are not enabled. diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index 99311635ab..d43f1d3830 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -168,12 +168,12 @@ TEST (vote_spacing, vote_generator) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); @@ -212,11 +212,11 @@ TEST (vote_spacing, rapid) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 625dbb795a..e7c8356eb5 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1114,7 +1114,7 @@ TEST (wallet, epoch_2_receive_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key.pub, node.network_params.work.epoch_2)) .build (); - ASSERT_EQ (nano::process_result::progress, node.process (*epoch2_unopened).code); + ASSERT_EQ (nano::block_status::progress, node.process (*epoch2_unopened)); wallet.insert_adhoc (key.prv, false); @@ -1175,7 +1175,7 @@ TEST (wallet, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 8b8d7c96ff..5e3d45dfb8 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -110,7 +110,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); auto open1 = builder .state () .account (key1.pub) @@ -121,7 +121,7 @@ TEST (wallets, vote_minimum) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1.process (*open1).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); // send2 with amount vote_minimum - 1 (not voting representative) auto send2 = builder .state () @@ -133,7 +133,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); auto open2 = builder .state () .account (key2.pub) @@ -144,7 +144,7 @@ TEST (wallets, vote_minimum) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1.process (*open2).code); + ASSERT_EQ (nano::block_status::progress, node1.process (*open2)); auto wallet (node1.wallets.items.begin ()->second); nano::unique_lock representatives_lk (wallet->representatives_mutex); ASSERT_EQ (0, wallet->representatives.size ()); @@ -212,7 +212,7 @@ TEST (wallets, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node.process (*send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index fb88af4901..bc2fa0140b 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -1061,7 +1061,7 @@ TEST (websocket, new_unconfirmed_block) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process_local (send1).value ().code); + ASSERT_EQ (nano::block_status::progress, node1->process_local (send1).value ()); ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready); diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index ed4fb36f6f..585bb4280b 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -35,9 +35,9 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi // Notify elections about alternative (forked) blocks block_processor.block_processed.add ([this] (auto const & result, auto const & context) { - switch (result.code) + switch (result) { - case nano::process_result::fork: + case nano::block_status::fork: publish (context.block); break; default: diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp index 31cde2956f..898a607f23 100644 --- a/nano/node/block_broadcast.cpp +++ b/nano/node/block_broadcast.cpp @@ -15,9 +15,9 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor) return; } block_processor.block_processed.add ([this] (auto const & result, auto const & context) { - switch (result.code) + switch (result) { - case nano::process_result::progress: + case nano::block_status::progress: observe (context); break; default: diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index a934ef7a97..471a3ccb6d 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -96,7 +96,7 @@ void nano::block_processor::add (std::shared_ptr const & block, blo add_impl (context{ block, source }); } -std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) +std::optional nano::block_processor::add_blocking (std::shared_ptr const & block, block_source const source) { node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process_blocking); node.logger.debug (nano::log::type::blockprocessor, "Processing block (blocking): {} (source: {})", block->hash ().to_string (), to_string (source)); @@ -312,24 +312,24 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock return processed; } -nano::process_return nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) +nano::block_status nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) { auto const & block = context.block; auto const hash = block->hash (); - nano::process_return result = node.ledger.process (transaction_a, *block); + nano::block_status result = node.ledger.process (transaction_a, *block); - node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result.code)); + node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result)); node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source)); node.logger.trace (nano::log::type::blockprocessor, nano::log::detail::block_processed, - nano::log::arg{ "result", result.code }, + nano::log::arg{ "result", result }, nano::log::arg{ "source", context.source }, nano::log::arg{ "arrival", nano::log::microseconds (context.arrival) }, nano::log::arg{ "forced", forced_a }, nano::log::arg{ "block", block }); - switch (result.code) + switch (result) { - case nano::process_result::progress: + case nano::block_status::progress: { queue_unchecked (transaction_a, hash); /* For send blocks check epoch open unchecked (gap pending). @@ -343,63 +343,63 @@ nano::process_return nano::block_processor::process_one (store::write_transactio } break; } - case nano::process_result::gap_previous: + case nano::block_status::gap_previous: { node.unchecked.put (block->previous (), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous); break; } - case nano::process_result::gap_source: + case nano::block_status::gap_source: { node.unchecked.put (node.ledger.block_source (transaction_a, *block), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } - case nano::process_result::gap_epoch_open_pending: + case nano::block_status::gap_epoch_open_pending: { node.unchecked.put (block->account (), block); // Specific unchecked key starting with epoch open block account public key node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } - case nano::process_result::old: + case nano::block_status::old: { node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old); break; } - case nano::process_result::bad_signature: + case nano::block_status::bad_signature: { break; } - case nano::process_result::negative_spend: + case nano::block_status::negative_spend: { break; } - case nano::process_result::unreceivable: + case nano::block_status::unreceivable: { break; } - case nano::process_result::fork: + case nano::block_status::fork: { node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork); break; } - case nano::process_result::opened_burn_account: + case nano::block_status::opened_burn_account: { break; } - case nano::process_result::balance_mismatch: + case nano::block_status::balance_mismatch: { break; } - case nano::process_result::representative_mismatch: + case nano::block_status::representative_mismatch: { break; } - case nano::process_result::block_position: + case nano::block_status::block_position: { break; } - case nano::process_result::insufficient_work: + case nano::block_status::insufficient_work: { break; } diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 78e55b4e87..ee5f4219d0 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -51,7 +51,7 @@ class block_processor final std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () }; public: - using result_t = nano::process_return; + using result_t = nano::block_status; std::future get_future (); private: @@ -69,7 +69,7 @@ class block_processor final bool full (); bool half_full (); void add (std::shared_ptr const &, block_source = block_source::live); - std::optional add_blocking (std::shared_ptr const & block, block_source); + std::optional add_blocking (std::shared_ptr const & block, block_source); void force (std::shared_ptr const &); bool should_log (); bool have_blocks_ready (); @@ -80,17 +80,17 @@ class block_processor final std::atomic flushing{ false }; public: // Events - using processed_t = std::tuple; + using processed_t = std::tuple; using processed_batch_t = std::deque; // The batch observer feeds the processed observer - nano::observer_set block_processed; + nano::observer_set block_processed; nano::observer_set batch_processed; private: // Roll back block in the ledger that conflicts with 'block' void rollback_competitor (store::write_transaction const &, nano::block const & block); - nano::process_return process_one (store::write_transaction const &, context const &, bool forced = false); + nano::block_status process_one (store::write_transaction const &, context const &, bool forced = false); void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &); processed_batch_t process_batch (nano::unique_lock &); context next (); diff --git a/nano/node/bootstrap/bootstrap.cpp b/nano/node/bootstrap/bootstrap.cpp index 48cb46b790..451b93aaea 100644 --- a/nano/node/bootstrap/bootstrap.cpp +++ b/nano/node/bootstrap/bootstrap.cpp @@ -165,7 +165,7 @@ bool nano::bootstrap_initiator::in_progress () return !attempts_list.empty (); } -void nano::bootstrap_initiator::block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block) +void nano::bootstrap_initiator::block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block) { nano::lock_guard lock{ mutex }; for (auto & i : attempts_list) diff --git a/nano/node/bootstrap/bootstrap.hpp b/nano/node/bootstrap/bootstrap.hpp index f9100da023..6d2052fc8f 100644 --- a/nano/node/bootstrap/bootstrap.hpp +++ b/nano/node/bootstrap/bootstrap.hpp @@ -105,7 +105,7 @@ class bootstrap_initiator final void notify_listeners (bool); void add_observer (std::function const &); bool in_progress (); - void block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block); + void block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block); std::shared_ptr connections; std::shared_ptr new_attempt (); bool has_new_attempts (); diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 3f78beff2a..4057dd8e0e 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -138,6 +138,6 @@ bool nano::bootstrap_attempt::process_block (std::shared_ptr const return stop_pull; } -void nano::bootstrap_attempt::block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block) +void nano::bootstrap_attempt::block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block) { } diff --git a/nano/node/bootstrap/bootstrap_attempt.hpp b/nano/node/bootstrap/bootstrap_attempt.hpp index fa9ed15e61..ea64fe9fd0 100644 --- a/nano/node/bootstrap/bootstrap_attempt.hpp +++ b/nano/node/bootstrap/bootstrap_attempt.hpp @@ -34,7 +34,7 @@ class bootstrap_attempt : public std::enable_shared_from_this char const * mode_text (); virtual bool process_block (std::shared_ptr const &, nano::account const &, uint64_t, nano::bulk_pull::count_t, bool, unsigned); virtual void get_information (boost::property_tree::ptree &) = 0; - virtual void block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block); + virtual void block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block); nano::mutex next_log_mutex; std::chrono::steady_clock::time_point next_log{ std::chrono::steady_clock::now () }; std::atomic pulling{ 0 }; diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 14430c0963..1ab1362849 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -124,13 +124,13 @@ std::size_t nano::bootstrap_ascending::service::score_size () const - Marks an account as blocked if the result code is gap source as there is no reason request additional blocks for this account until the dependency is resolved - Marks an account as forwarded if it has been recently referenced by a block that has been inserted. */ -void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, nano::process_return const & result, nano::block const & block) +void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, nano::block_status const & result, nano::block const & block) { auto const hash = block.hash (); - switch (result.code) + switch (result) { - case nano::process_result::progress: + case nano::block_status::progress: { const auto account = ledger.account (tx, hash); const auto is_send = ledger.is_send (tx, block); @@ -164,7 +164,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, } } break; - case nano::process_result::gap_source: + case nano::block_status::gap_source: { const auto account = block.previous ().is_zero () ? block.account () : ledger.account (tx, block.previous ()); const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); @@ -175,12 +175,12 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, // TODO: Track stats } break; - case nano::process_result::old: + case nano::block_status::old: { // TODO: Track stats } break; - case nano::process_result::gap_previous: + case nano::block_status::gap_previous: { // TODO: Track stats } diff --git a/nano/node/bootstrap_ascending/service.hpp b/nano/node/bootstrap_ascending/service.hpp index 3c7a436f7c..4b7ed0e1ed 100644 --- a/nano/node/bootstrap_ascending/service.hpp +++ b/nano/node/bootstrap_ascending/service.hpp @@ -88,7 +88,7 @@ namespace bootstrap_ascending private: /* Inspects a block that has been processed by the block processor */ - void inspect (store::transaction const &, nano::process_return const & result, nano::block const & block); + void inspect (store::transaction const &, nano::block_status const & result, nano::block const & block); void throttle_if_needed (nano::unique_lock & lock); void run (); diff --git a/nano/node/epoch_upgrader.cpp b/nano/node/epoch_upgrader.cpp index df30195032..9072b53291 100644 --- a/nano/node/epoch_upgrader.cpp +++ b/nano/node/epoch_upgrader.cpp @@ -47,18 +47,18 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc epoch->block_work_set (node.work_generate_blocking (nano::work_version::work_1, root_a, difficulty).value_or (0)); bool valid_signature (!nano::validate_message (signer_a, epoch->hash (), epoch->block_signature ())); bool valid_work (node.network_params.work.difficulty (*epoch) >= difficulty); - nano::process_result result (nano::process_result::old); + nano::block_status result (nano::block_status::old); if (valid_signature && valid_work) { - result = node.process_local (epoch).value ().code; + result = node.process_local (epoch).value (); } - if (result == nano::process_result::progress) + if (result == nano::block_status::progress) { ++counter; } else { - bool fork (result == nano::process_result::fork); + bool fork (result == nano::block_status::fork); logger.error (nano::log::type::epoch_upgrader, "Failed to upgrade account {} (valid signature: {}, valid work: {}, fork: {})", account_a.to_account (), diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 91034d0510..c84a257b14 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -3271,60 +3271,60 @@ void nano::json_handler::process () else { auto const & result = result_maybe.value (); - switch (result.code) + switch (result) { - case nano::process_result::progress: + case nano::block_status::progress: { rpc_l->response_l.put ("hash", block->hash ().to_string ()); break; } - case nano::process_result::gap_previous: + case nano::block_status::gap_previous: { rpc_l->ec = nano::error_process::gap_previous; break; } - case nano::process_result::gap_source: + case nano::block_status::gap_source: { rpc_l->ec = nano::error_process::gap_source; break; } - case nano::process_result::old: + case nano::block_status::old: { rpc_l->ec = nano::error_process::old; break; } - case nano::process_result::bad_signature: + case nano::block_status::bad_signature: { rpc_l->ec = nano::error_process::bad_signature; break; } - case nano::process_result::negative_spend: + case nano::block_status::negative_spend: { // TODO once we get RPC versioning, this should be changed to "negative spend" rpc_l->ec = nano::error_process::negative_spend; break; } - case nano::process_result::balance_mismatch: + case nano::block_status::balance_mismatch: { rpc_l->ec = nano::error_process::balance_mismatch; break; } - case nano::process_result::unreceivable: + case nano::block_status::unreceivable: { rpc_l->ec = nano::error_process::unreceivable; break; } - case nano::process_result::block_position: + case nano::block_status::block_position: { rpc_l->ec = nano::error_process::block_position; break; } - case nano::process_result::gap_epoch_open_pending: + case nano::block_status::gap_epoch_open_pending: { rpc_l->ec = nano::error_process::gap_epoch_open_pending; break; } - case nano::process_result::fork: + case nano::block_status::fork: { bool const force = rpc_l->request.get ("force", false); if (force) @@ -3339,12 +3339,12 @@ void nano::json_handler::process () } break; } - case nano::process_result::insufficient_work: + case nano::block_status::insufficient_work: { rpc_l->ec = nano::error_process::insufficient_work; break; } - case nano::process_result::opened_burn_account: + case nano::block_status::opened_burn_account: rpc_l->ec = nano::error_process::opened_burn_account; break; default: diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 641ee89467..fe55224fa8 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -559,18 +559,18 @@ void nano::node::process_active (std::shared_ptr const & incoming) block_processor.add (incoming); } -[[nodiscard]] nano::process_return nano::node::process (store::write_transaction const & transaction, nano::block & block) +[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, nano::block & block) { return ledger.process (transaction, block); } -nano::process_return nano::node::process (nano::block & block) +nano::block_status nano::node::process (nano::block & block) { auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending }); return process (transaction, block); } -std::optional nano::node::process_local (std::shared_ptr const & block_a) +std::optional nano::node::process_local (std::shared_ptr const & block_a) { return block_processor.add_blocking (block_a, nano::block_source::local); } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 19e5a7a2ab..247dd35ccf 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -86,7 +86,7 @@ class node final : public std::enable_shared_from_this void process_confirmed_data (store::transaction const &, std::shared_ptr const &, nano::block_hash const &, nano::account &, nano::uint128_t &, bool &, bool &, nano::account &); void process_confirmed (nano::election_status const &, uint64_t = 0); void process_active (std::shared_ptr const &); - std::optional process_local (std::shared_ptr const &); + std::optional process_local (std::shared_ptr const &); void process_local_async (std::shared_ptr const &); void keepalive_preconfigured (std::vector const &); std::shared_ptr block (nano::block_hash const &); @@ -210,8 +210,8 @@ class node final : public std::enable_shared_from_this Creates a new write transaction and inserts `block' and returns result Transaction is comitted before function return */ - [[nodiscard]] nano::process_return process (nano::block & block); - [[nodiscard]] nano::process_return process (store::write_transaction const &, nano::block & block); + [[nodiscard]] nano::block_status process (nano::block & block); + [[nodiscard]] nano::block_status process (store::write_transaction const &, nano::block & block); nano::block_hash latest (nano::account const &); nano::uint128_t balance (nano::account const &); diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index 9dfe769c66..8411851d42 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -28,11 +28,11 @@ void nano::process_live_dispatcher::connect (nano::block_processor & block_proce }); } -void nano::process_live_dispatcher::inspect (nano::process_return const & result, nano::block const & block, store::transaction const & transaction) +void nano::process_live_dispatcher::inspect (nano::block_status const & result, nano::block const & block, store::transaction const & transaction) { - switch (result.code) + switch (result) { - case nano::process_result::progress: + case nano::block_status::progress: process_live (block, transaction); break; default: diff --git a/nano/node/process_live_dispatcher.hpp b/nano/node/process_live_dispatcher.hpp index ec30d94913..210656eb7c 100644 --- a/nano/node/process_live_dispatcher.hpp +++ b/nano/node/process_live_dispatcher.hpp @@ -28,7 +28,7 @@ class process_live_dispatcher private: // Block_processor observer - void inspect (nano::process_return const & result, nano::block const & block, store::transaction const & transaction); + void inspect (nano::block_status const & result, nano::block const & block, store::transaction const & transaction); void process_live (nano::block const & block, store::transaction const & transaction); nano::ledger & ledger; diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 09f2399757..7dd08665d1 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1054,7 +1054,7 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a if (!error) { auto result = wallets.node.process_local (block_a); - error = !result || result.value ().code != nano::process_result::progress; + error = !result || result.value () != nano::block_status::progress; debug_assert (error || block_a->sideband ().details == details_a); } if (!error && generate_work_a) diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index b7b6621ae3..e1750a9ae3 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -424,8 +424,8 @@ TEST (wallet, create_send) bool error (false); nano::state_block send (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (send).code); - ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (send).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (send)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send)); } TEST (wallet, create_open_receive) @@ -458,8 +458,8 @@ TEST (wallet, create_open_receive) bool error (false); nano::state_block open (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); - ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (open).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open)); wallet->block_creation.block->clear (); wallet->block_creation.source->clear (); wallet->block_creation.receive->click (); @@ -473,8 +473,8 @@ TEST (wallet, create_open_receive) bool error2 (false); nano::state_block receive (error2, tree2); ASSERT_FALSE (error2); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (receive).code); - ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (receive).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (receive)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive)); } TEST (wallet, create_change) @@ -501,8 +501,8 @@ TEST (wallet, create_change) bool error (false); nano::state_block change (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (change).code); - ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (change).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (change)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change)); } TEST (history, short_text) @@ -532,11 +532,11 @@ TEST (history, short_text) nano::keypair key; auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); nano::send_block send (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); nano::change_block change (receive.hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); } nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet); history.refresh (); @@ -572,13 +572,13 @@ TEST (history, pruned_source) store->initialize (transaction, ledger.cache, nano::dev::constants); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::send_block send2 (send1.hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); nano::receive_block receive (send2.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); nano::open_block open (send2.hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 2)); next_pruning = send2.hash (); } @@ -602,10 +602,10 @@ TEST (history, pruned_source) auto transaction (store->tx_begin_write ()); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); nano::state_block send (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto latest_key (ledger.latest (transaction, key.pub)); nano::state_block receive (key.pub, latest_key, key.pub, 200, send.hash (), key.prv, key.pub, *system.work.generate (latest_key)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest, 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 2)); } @@ -718,7 +718,7 @@ TEST (wallet, republish) auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); nano::send_block block (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); hash = block.hash (); - ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block)); } auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); @@ -967,7 +967,7 @@ TEST (wallet, epoch_2_validation) bool error (false); nano::state_block block (error, tree1); EXPECT_FALSE (error); - EXPECT_EQ (nano::process_result::progress, node->process (block).code); + EXPECT_EQ (nano::block_status::progress, node->process (block)); return block.hash (); }; diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 09d7816dbe..972dcbfa04 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -370,7 +370,7 @@ TEST (rpc, search_receivable) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 3c4d2337d6..3a5bf6dfe8 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -72,7 +72,7 @@ TEST (rpc, account_balance) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send1)); ASSERT_TIMELY (5s, !node->active.active (*send1)); auto const rpc_ctx = add_rpc (system, node); @@ -152,7 +152,7 @@ TEST (rpc, account_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*block).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*block)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_weight"); @@ -957,9 +957,9 @@ TEST (rpc, history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *usend).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *ureceive).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *uchange).code); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); } auto const rpc_ctx = add_rpc (system, node0); boost::property_tree::ptree request; @@ -1041,9 +1041,9 @@ TEST (rpc, account_history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *usend).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *ureceive).code); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *uchange).code); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); } auto const rpc_ctx = add_rpc (system, node0); { @@ -1557,8 +1557,8 @@ TEST (rpc, process_subtype_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); - ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node2.process (*send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto open = builder @@ -1606,8 +1606,8 @@ TEST (rpc, process_subtype_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); - ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node2.process (*send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto receive = builder @@ -2497,7 +2497,7 @@ TEST (rpc, bootstrap) .build (); { auto transaction (node1->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, *send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2782,7 +2782,7 @@ TEST (rpc, bootstrap_any) .build (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, *send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2808,7 +2808,7 @@ TEST (rpc, republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -2817,7 +2817,7 @@ TEST (rpc, republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "republish"); @@ -2998,7 +2998,7 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables) .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } ASSERT_TIMELY (5s, node->block (send->hash ())); ASSERT_TIMELY (5s, !node->active.active (*send)); @@ -3531,7 +3531,7 @@ TEST (rpc, search_receivable_all) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -3563,7 +3563,7 @@ TEST (rpc, wallet_republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -3572,7 +3572,7 @@ TEST (rpc, wallet_republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); @@ -3607,7 +3607,7 @@ TEST (rpc, delegators) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -3616,7 +3616,7 @@ TEST (rpc, delegators) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators"); @@ -3648,7 +3648,7 @@ TEST (rpc, delegators_parameters) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -3657,7 +3657,7 @@ TEST (rpc, delegators_parameters) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto const rpc_ctx = add_rpc (system, node1); // Test with "count" = 2 @@ -3758,7 +3758,7 @@ TEST (rpc, delegators_count) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -3767,7 +3767,7 @@ TEST (rpc, delegators_count) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators_count"); @@ -3810,7 +3810,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto time = nano::seconds_since_epoch (); { auto transaction = node1->store.tx_begin_write (); @@ -3869,7 +3869,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -3878,7 +3878,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); auto state_change = builder .state () @@ -3890,7 +3890,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send2->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*state_change).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*state_change)); auto open = builder .open () @@ -3900,7 +3900,7 @@ TEST (rpc, account_info) .sign (key1.prv, key1.pub) .work (*node1->work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_TIMELY (5s, !node1->active.active (*state_change)); ASSERT_TIMELY (5s, !node1->active.active (*open)); } @@ -4018,7 +4018,7 @@ TEST (rpc, json_block_output) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4240,7 +4240,7 @@ TEST (rpc, block_info_successor) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4430,7 +4430,7 @@ TEST (rpc, populate_backlog) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4461,7 +4461,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -4470,7 +4470,7 @@ TEST (rpc, ledger) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node->process (*open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4544,7 +4544,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send2)); // When asking for pending, pending amount is taken into account for threshold so the account must show up request.put ("count", 2); request.put ("threshold", (send_amount + send2_amount).convert_to ()); @@ -4631,7 +4631,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream, block_l); auto send_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (send->hash (), send_block->hash ()); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); boost::property_tree::ptree request1; request1.put ("action", "block_create"); request1.put ("type", "open"); @@ -4649,7 +4649,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream1, block_l); auto open_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (open->hash (), open_block->hash ()); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); request1.put ("representative", key.pub.to_account ()); auto response2 (wait_response (system, rpc_ctx, request1)); std::string open2_hash (response2.get ("hash")); @@ -4672,7 +4672,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream4, block_l); auto change_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (change->hash (), change_block->hash ()); - ASSERT_EQ (nano::process_result::progress, node1->process (*change).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*change)); auto send2 = builder .send () .previous (send->hash ()) @@ -4681,7 +4681,7 @@ TEST (rpc, block_create) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); boost::property_tree::ptree request2; request2.put ("action", "block_create"); request2.put ("type", "receive"); @@ -4730,7 +4730,7 @@ TEST (rpc, block_create_state) ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto process_result (node->process (*state_block)); - ASSERT_EQ (nano::process_result::progress, process_result.code); + ASSERT_EQ (nano::block_status::progress, process_result); } TEST (rpc, block_create_state_open) @@ -4766,7 +4766,7 @@ TEST (rpc, block_create_state_open) ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); auto process_result (node->process (*state_block)); - ASSERT_EQ (nano::process_result::progress, process_result.code); + ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_TRUE (state_block->sideband ().details.is_receive); ASSERT_FALSE (node->latest (key.pub).is_zero ()); @@ -4845,7 +4845,7 @@ TEST (rpc, block_create_open_epoch_v2) ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); auto process_result (node->process (*state_block)); - ASSERT_EQ (nano::process_result::progress, process_result.code); + ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); ASSERT_FALSE (node->latest (key.pub).is_zero ()); @@ -4871,7 +4871,7 @@ TEST (rpc, block_create_receive_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node->process (*open)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); auto send_block_2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio)); auto const rpc_ctx = add_rpc (system, node); @@ -4897,7 +4897,7 @@ TEST (rpc, block_create_receive_epoch_v2) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); auto process_result (node->process (*state_block)); - ASSERT_EQ (nano::process_result::progress, process_result.code); + ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); ASSERT_FALSE (node->latest (key.pub).is_zero ()); @@ -4924,7 +4924,7 @@ TEST (rpc, block_create_send_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node->process (*open)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); @@ -4948,7 +4948,7 @@ TEST (rpc, block_create_send_epoch_v2) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); auto process_result (node->process (*state_block)); - ASSERT_EQ (nano::process_result::progress, process_result.code); + ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_send); ASSERT_FALSE (node->latest (key.pub).is_zero ()); @@ -5048,7 +5048,7 @@ TEST (rpc, wallet_ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send)); auto open = builder .open () .source (send->hash ()) @@ -5057,7 +5057,7 @@ TEST (rpc, wallet_ledger) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; @@ -5221,7 +5221,7 @@ TEST (rpc, confirmation_height_currently_processing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); previous_genesis_chain_hash = send->hash (); } @@ -5343,7 +5343,7 @@ TEST (rpc, block_confirm) .build_shared (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -5850,7 +5850,7 @@ TEST (rpc, block_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); auto open1 = builder .open () @@ -5860,7 +5860,7 @@ TEST (rpc, block_confirmed) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); } // This should not be confirmed @@ -6144,7 +6144,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); // to opened account - ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6155,7 +6155,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); // to unopened account (pending) - ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6166,7 +6166,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); // to burn (0) - ASSERT_EQ (nano::process_result::progress, node->process (*send3).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6178,7 +6178,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build_shared (); // to max account - ASSERT_EQ (nano::process_result::progress, node->process (*send4).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send4)); auto open = builder .state () .account (key1.pub) @@ -6189,7 +6189,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node->process (*open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6235,7 +6235,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build_shared (); // to burn (0) - ASSERT_EQ (nano::process_result::progress, node->process (*send5).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6246,7 +6246,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build_shared (); // to key1 (again) - ASSERT_EQ (nano::process_result::progress, node->process (*send6).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6258,7 +6258,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build_shared (); // to key3 - ASSERT_EQ (nano::process_result::progress, node->process (*send7).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6307,7 +6307,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); // to opened account - ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6318,7 +6318,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); // to unopened account (pending) - ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6329,7 +6329,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); // to burn (0) - ASSERT_EQ (nano::process_result::progress, node->process (*send3).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6341,7 +6341,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build_shared (); // to max account - ASSERT_EQ (nano::process_result::progress, node->process (*send4).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send4)); auto open = builder .state () .account (key1.pub) @@ -6352,7 +6352,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node->process (*open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6399,7 +6399,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build_shared (); // to burn (0) - ASSERT_EQ (nano::process_result::progress, node->process (*send5).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6410,7 +6410,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build_shared (); // to key1 (again) - ASSERT_EQ (nano::process_result::progress, node->process (*send6).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6422,7 +6422,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build_shared (); // to key3 - ASSERT_EQ (nano::process_result::progress, node->process (*send7).code); + ASSERT_EQ (nano::block_status::progress, node->process (*send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6471,7 +6471,7 @@ TEST (rpc, account_lazy_start) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto open = builder .open () .source (send1->hash ()) @@ -6480,7 +6480,7 @@ TEST (rpc, account_lazy_start) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // Start lazy bootstrap with account nano::node_config node_config = system.default_config (); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 4d86b31a08..d34f9daf07 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -497,14 +497,14 @@ void nano::generate_cache::enable_all () account_count = true; } -std::string_view nano::to_string (nano::process_result process_result) +std::string_view nano::to_string (nano::block_status code) { - return magic_enum::enum_name (process_result); + return magic_enum::enum_name (code); } -nano::stat::detail nano::to_stat_detail (nano::process_result process_result) +nano::stat::detail nano::to_stat_detail (nano::block_status code) { - auto value = magic_enum::enum_cast (magic_enum::enum_name (process_result)); + auto value = magic_enum::enum_cast (magic_enum::enum_name (code)); debug_assert (value); return value.value_or (nano::stat::detail{}); } diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 190b8561cc..2e183267d4 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -253,7 +253,7 @@ enum class vote_code indeterminate // Unknown if replay or vote }; -enum class process_result +enum class block_status { progress, // Hasn't been seen before, signed correctly bad_signature, // Signature was bad, forged or transmission error @@ -271,14 +271,9 @@ enum class process_result insufficient_work // Insufficient work for this block, even though it passed the minimal validation }; -std::string_view to_string (process_result); -nano::stat::detail to_stat_detail (process_result); +std::string_view to_string (block_status); +nano::stat::detail to_stat_detail (block_status); -class process_return final -{ -public: - nano::process_result code; -}; enum class tally_result { vote, diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index b4858da20b..62503f5c1d 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -203,7 +203,7 @@ class ledger_processor : public nano::mutable_block_visitor void epoch_block_impl (nano::state_block &); nano::ledger & ledger; nano::store::write_transaction const & transaction; - nano::process_return result; + nano::block_status result; private: bool validate_epoch_block (nano::state_block const & block_a); @@ -216,8 +216,8 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) nano::amount prev_balance (0); if (!block_a.hashables.previous.is_zero ()) { - result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; - if (result.code == nano::process_result::progress) + result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::progress : nano::block_status::gap_previous; + if (result == nano::block_status::progress) { prev_balance = ledger.balance (transaction, block_a.hashables.previous); } @@ -229,7 +229,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) // Is epoch block signed correctly if (validate_message (ledger.epoch_signer (block_a.link ()), block_a.hash (), block_a.signature)) { - result.code = nano::process_result::bad_signature; + result = nano::block_status::bad_signature; } } } @@ -239,7 +239,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) void ledger_processor::state_block (nano::state_block & block_a) { - result.code = nano::process_result::progress; + result = nano::block_status::progress; auto is_epoch_block = false; if (ledger.is_epoch_link (block_a.hashables.link)) { @@ -247,7 +247,7 @@ void ledger_processor::state_block (nano::state_block & block_a) is_epoch_block = validate_epoch_block (block_a); } - if (result.code == nano::process_result::progress) + if (result == nano::block_status::progress) { if (is_epoch_block) { @@ -264,15 +264,15 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Unambiguous) + if (result == nano::block_status::progress) { - result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous) - if (result.code == nano::process_result::progress) + result = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Unambiguous) + if (result == nano::block_status::progress) { debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); - 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) + result = block_a.hashables.account.is_zero () ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is this for the burn account? (Unambiguous) + if (result == nano::block_status::progress) { nano::epoch epoch (nano::epoch::epoch_0); nano::epoch source_epoch (nano::epoch::epoch_0); @@ -285,44 +285,44 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) { // Account already exists epoch = info.epoch (); - result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious) - if (result.code == nano::process_result::progress) + result = block_a.hashables.previous.is_zero () ? nano::block_status::fork : nano::block_status::progress; // Has this account already been opened? (Ambigious) + if (result == nano::block_status::progress) { - result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) - if (result.code == nano::process_result::progress) + result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::progress : nano::block_status::gap_previous; // Does the previous block exist in the ledger? (Unambigious) + if (result == nano::block_status::progress) { is_send = block_a.hashables.balance < info.balance; is_receive = !is_send && !block_a.hashables.link.is_zero (); amount = is_send ? (info.balance.number () - amount.number ()) : (amount.number () - info.balance.number ()); - result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious) + result = block_a.hashables.previous == info.head ? nano::block_status::progress : nano::block_status::fork; // Is the previous block the account's head block? (Ambigious) } } } else { // Account does not yet exists - result.code = block_a.previous ().is_zero () ? nano::process_result::progress : nano::process_result::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious) - if (result.code == nano::process_result::progress) + result = block_a.previous ().is_zero () ? nano::block_status::progress : nano::block_status::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious) + if (result == nano::block_status::progress) { is_receive = true; - result.code = !block_a.hashables.link.is_zero () ? nano::process_result::progress : nano::process_result::gap_source; // Is the first block receiving from a send ? (Unambigious) + result = !block_a.hashables.link.is_zero () ? nano::block_status::progress : nano::block_status::gap_source; // Is the first block receiving from a send ? (Unambigious) } } - if (result.code == nano::process_result::progress) + if (result == nano::block_status::progress) { if (!is_send) { if (!block_a.hashables.link.is_zero ()) { - result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless) - if (result.code == nano::process_result::progress) + result = ledger.block_or_pruned_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block already? (Harmless) + if (result == nano::block_status::progress) { nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()); nano::pending_info pending; - result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + if (result == nano::block_status::progress) { - result.code = amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch; + result = amount == pending.amount ? nano::block_status::progress : nano::block_status::balance_mismatch; source_epoch = pending.epoch; epoch = std::max (epoch, source_epoch); } @@ -331,15 +331,15 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) else { // If there's no link, the balance must remain the same, only the representative can change - result.code = amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch; + result = amount.is_zero () ? nano::block_status::progress : nano::block_status::balance_mismatch; } } } - if (result.code == nano::process_result::progress) + if (result == nano::block_status::progress) { nano::block_details block_details (epoch, is_send, is_receive, false); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::state_block); block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, source_epoch)); @@ -384,55 +384,55 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Unambiguous) + if (result == nano::block_status::progress) { - result.code = validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous) - if (result.code == nano::process_result::progress) + result = validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Unambiguous) + if (result == nano::block_status::progress) { debug_assert (!validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature)); - 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) + result = block_a.hashables.account.is_zero () ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is this for the burn account? (Unambiguous) + if (result == nano::block_status::progress) { nano::account_info info; auto account_error (ledger.store.account.get (transaction, block_a.hashables.account, info)); if (!account_error) { // Account already exists - result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious) - if (result.code == nano::process_result::progress) + result = block_a.hashables.previous.is_zero () ? nano::block_status::fork : nano::block_status::progress; // Has this account already been opened? (Ambigious) + if (result == nano::block_status::progress) { - result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious) - if (result.code == nano::process_result::progress) + result = block_a.hashables.previous == info.head ? nano::block_status::progress : nano::block_status::fork; // Is the previous block the account's head block? (Ambigious) + if (result == nano::block_status::progress) { - result.code = block_a.hashables.representative == info.representative ? nano::process_result::progress : nano::process_result::representative_mismatch; + result = block_a.hashables.representative == info.representative ? nano::block_status::progress : nano::block_status::representative_mismatch; } } } else { - result.code = block_a.hashables.representative.is_zero () ? nano::process_result::progress : nano::process_result::representative_mismatch; + result = block_a.hashables.representative.is_zero () ? nano::block_status::progress : nano::block_status::representative_mismatch; // Non-exisitng account should have pending entries - if (result.code == nano::process_result::progress) + if (result == nano::block_status::progress) { bool pending_exists = ledger.store.pending.any (transaction, block_a.hashables.account); - result.code = pending_exists ? nano::process_result::progress : nano::process_result::gap_epoch_open_pending; + result = pending_exists ? nano::block_status::progress : nano::block_status::gap_epoch_open_pending; } } - if (result.code == nano::process_result::progress) + if (result == nano::block_status::progress) { auto epoch = ledger.constants.epochs.epoch (block_a.hashables.link); // Must be an epoch for an unopened account or the epoch upgrade must be sequential auto is_valid_epoch_upgrade = account_error ? static_cast> (epoch) > 0 : nano::epochs::is_sequential (info.epoch (), epoch); - result.code = is_valid_epoch_upgrade ? nano::process_result::progress : nano::process_result::block_position; - if (result.code == nano::process_result::progress) + result = is_valid_epoch_upgrade ? nano::block_status::progress : nano::block_status::block_position; + if (result == nano::block_status::progress) { - result.code = block_a.hashables.balance == info.balance ? nano::process_result::progress : nano::process_result::balance_mismatch; - if (result.code == nano::process_result::progress) + result = block_a.hashables.balance == info.balance ? nano::block_status::progress : nano::block_status::balance_mismatch; + if (result == nano::block_status::progress) { nano::block_details block_details (epoch, false, false, true); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block); block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); @@ -456,29 +456,29 @@ void ledger_processor::change_block (nano::change_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Harmless) + if (result == nano::block_status::progress) { auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) - if (result.code == nano::process_result::progress) + result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous; // Have we seen the previous block already? (Harmless) + if (result == nano::block_status::progress) { - result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; - if (result.code == nano::process_result::progress) + result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position; + if (result == nano::block_status::progress) { auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; - if (result.code == nano::process_result::progress) + result = account.is_zero () ? nano::block_status::fork : nano::block_status::progress; + if (result == nano::block_status::progress) { auto info = ledger.account_info (transaction, account); debug_assert (info); debug_assert (info->head == block_a.hashables.previous); - result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed) - if (result.code == nano::process_result::progress) + result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Malformed) + if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { debug_assert (!validate_message (account, hash, block_a.signature)); block_a.sideband_set (nano::block_sideband (account, 0, info->balance, info->block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); @@ -502,33 +502,33 @@ void ledger_processor::send_block (nano::send_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Harmless) + if (result == nano::block_status::progress) { auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) - if (result.code == nano::process_result::progress) + result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous; // Have we seen the previous block already? (Harmless) + if (result == nano::block_status::progress) { - result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; - if (result.code == nano::process_result::progress) + result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position; + if (result == nano::block_status::progress) { auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; - if (result.code == nano::process_result::progress) + result = account.is_zero () ? nano::block_status::fork : nano::block_status::progress; + if (result == nano::block_status::progress) { - result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed) - if (result.code == nano::process_result::progress) + result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Malformed) + if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { debug_assert (!validate_message (account, hash, block_a.signature)); auto info = ledger.account_info (transaction, account); debug_assert (info); 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) + result = info->balance.number () >= block_a.hashables.balance.number () ? nano::block_status::progress : nano::block_status::negative_spend; // Is this trying to spend a negative amount (Malicious) + if (result == nano::block_status::progress) { auto amount (info->balance.number () - block_a.hashables.balance.number ()); ledger.cache.rep_weights.representation_add (info->representative, 0 - amount); @@ -553,43 +553,43 @@ void ledger_processor::receive_block (nano::receive_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block already? (Harmless) + if (result == nano::block_status::progress) { auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; - if (result.code == nano::process_result::progress) + result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous; + if (result == nano::block_status::progress) { - result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; - if (result.code == nano::process_result::progress) + result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position; + if (result == nano::block_status::progress) { auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? nano::process_result::gap_previous : nano::process_result::progress; // Have we seen the previous block? No entries for account at all (Harmless) - if (result.code == nano::process_result::progress) + result = account.is_zero () ? nano::block_status::gap_previous : nano::block_status::progress; // Have we seen the previous block? No entries for account at all (Harmless) + if (result == nano::block_status::progress) { - result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed) - if (result.code == nano::process_result::progress) + result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is the signature valid (Malformed) + if (result == nano::block_status::progress) { debug_assert (!validate_message (account, hash, block_a.signature)); - result.code = ledger.block_or_pruned_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) + result = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block already? (Harmless) + if (result == nano::block_status::progress) { auto info = ledger.account_info (transaction, account); debug_assert (info); - result.code = info->head == block_a.hashables.previous ? nano::process_result::progress : nano::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless) - if (result.code == nano::process_result::progress) + result = info->head == block_a.hashables.previous ? nano::block_status::progress : nano::block_status::gap_previous; // Block doesn't immediately follow latest block (Harmless) + if (result == nano::block_status::progress) { nano::pending_key key (account, block_a.hashables.source); nano::pending_info pending; - result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + if (result == nano::block_status::progress) { - result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) - if (result.code == nano::process_result::progress) + result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) + if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { auto new_balance (info->balance.number () + pending.amount.number ()); #ifdef NDEBUG @@ -617,7 +617,7 @@ void ledger_processor::receive_block (nano::receive_block & block_a) } else { - result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) + result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::fork : nano::block_status::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) } } } @@ -628,34 +628,34 @@ void ledger_processor::open_block (nano::open_block & block_a) { auto hash (block_a.hash ()); auto existing (ledger.block_or_pruned_exists (transaction, hash)); - result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless) - if (result.code == nano::process_result::progress) + result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block already? (Harmless) + if (result == nano::block_status::progress) { - result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed) - if (result.code == nano::process_result::progress) + result = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is the signature valid (Malformed) + if (result == nano::block_status::progress) { debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature)); - result.code = ledger.block_or_pruned_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) + result = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block? (Harmless) + if (result == nano::block_status::progress) { nano::account_info info; - result.code = ledger.store.account.get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious) - if (result.code == nano::process_result::progress) + result = ledger.store.account.get (transaction, block_a.hashables.account, info) ? nano::block_status::progress : nano::block_status::fork; // Has this account already been opened? (Malicious) + if (result == nano::block_status::progress) { nano::pending_key key (block_a.hashables.account, block_a.hashables.source); nano::pending_info pending; - result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + if (result == nano::block_status::progress) { - result.code = block_a.hashables.account == ledger.constants.burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious) - if (result.code == nano::process_result::progress) + result = block_a.hashables.account == ledger.constants.burn_account ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is it burning 0 account? (Malicious) + if (result == nano::block_status::progress) { - result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) - if (result.code == nano::process_result::progress) + result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) + if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) - if (result.code == nano::process_result::progress) + result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) + if (result == nano::block_status::progress) { #ifdef NDEBUG if (ledger.store.block.exists (transaction, block_a.hashables.source)) @@ -915,12 +915,12 @@ std::optional nano::ledger::pending_info (store::transaction return std::nullopt; } -nano::process_return nano::ledger::process (store::write_transaction const & transaction_a, nano::block & block_a) +nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, nano::block & block_a) { debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis); ledger_processor processor (*this, transaction_a); block_a.visit (processor); - if (processor.result.code == nano::process_result::progress) + if (processor.result == nano::block_status::progress) { ++cache.block_count; } diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index b11781ab94..9f3c69a571 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -72,7 +72,7 @@ class ledger final nano::block_hash block_source (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; - nano::process_return process (store::write_transaction const &, nano::block &); + nano::block_status process (store::write_transaction const &, nano::block &); bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector> &); bool rollback (store::write_transaction const &, nano::block_hash const &); void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index c36a60b4f9..ed8ef26976 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -136,7 +136,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto open = builder .open () .source (send->hash ()) @@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); auto sprevious (send->hash ()); auto rprevious (open->hash ()); for (auto i (0), n (100000); i != n; ++i) @@ -159,7 +159,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (sprevious)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); sprevious = send->hash (); auto receive = builder .receive () @@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (rprevious)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); rprevious = receive->hash (); if (i % 100 == 0) { @@ -278,7 +278,7 @@ TEST (node, fork_storm) for (auto node_i : system.nodes) { auto send_result (node_i->process (*send)); - ASSERT_EQ (nano::process_result::progress, send_result.code); + ASSERT_EQ (nano::block_status::progress, send_result); nano::keypair rep; auto open = builder .open () @@ -290,7 +290,7 @@ TEST (node, fork_storm) .build_shared (); node_i->work_generate_blocking (*open); auto open_result (node_i->process (*open)); - ASSERT_EQ (nano::process_result::progress, open_result.code); + ASSERT_EQ (nano::block_status::progress, open_result); auto transaction (node_i->store.tx_begin_read ()); node_i->network.flood_block (open); } @@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (last_keypair.prv, last_keypair.pub) .work (*system.work.generate (last_open_hash)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); auto open = builder .open () .source (send->hash ()) @@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); last_open_hash = open->hash (); last_keypair = key; } @@ -744,7 +744,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); auto open = builder .open () .source (send->hash ()) @@ -753,7 +753,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); } // Bulk send from genesis account to destination account @@ -845,7 +845,7 @@ TEST (confirmation_height, long_chains) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); auto receive = builder .receive () .previous (previous_destination_chain_hash) @@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains) .sign (key1.prv, key1.pub) .work (*system.work.generate (previous_destination_chain_hash)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); previous_genesis_chain_hash = send->hash (); previous_destination_chain_hash = receive->hash (); @@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); } // Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts @@ -970,7 +970,7 @@ TEST (confirmation_height, dynamic_algorithm) auto transaction = node->store.tx_begin_write (); for (auto const & block : state_blocks) { - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); } } @@ -1031,7 +1031,7 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) .build_shared (); latest_genesis = send->hash (); state_blocks.push_back (send); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); ++num; }; @@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); auto open = builder .open () .source (send->hash ()) @@ -1125,7 +1125,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1263,7 +1263,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto open = builder .open () .source (send->hash ()) @@ -1272,7 +1272,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build_shared (); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1316,8 +1316,8 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .work (*system.work.generate (send_blocks.back ()->hash ())) .build_shared ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send_blocks.back ()).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive_blocks.back ()).code); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ())); } } @@ -1688,7 +1688,7 @@ TEST (telemetry, many_nodes) for (auto node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); } // This is the node which will request metrics from all other nodes @@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::process_result::progress, node.process (*block).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block)); latest = block->hash (); info.pending_hash = block->hash (); } @@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::process_result::progress, node.process (*block).code); + ASSERT_EQ (nano::block_status::progress, node.process (*block)); } ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count); ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count); @@ -2043,7 +2043,7 @@ TEST (node, aggressive_flooding) for (auto const & block : genesis_blocks) { auto process_result (node_wallet.first->process (*block)); - ASSERT_TRUE (nano::process_result::progress == process_result.code || nano::process_result::old == process_result.code); + ASSERT_TRUE (nano::block_status::progress == process_result || nano::block_status::old == process_result); } ASSERT_EQ (node1.latest (nano::dev::genesis_key.pub), node_wallet.first->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (genesis_blocks.back ()->hash (), node_wallet.first->latest (nano::dev::genesis_key.pub)); @@ -2083,7 +2083,7 @@ TEST (node, aggressive_flooding) .build (); } // Processing locally goes through the aggressive block flooding path - ASSERT_EQ (nano::process_result::progress, node1.process_local (block).value ().code); + ASSERT_EQ (nano::block_status::progress, node1.process_local (block).value ()); auto all_have_block = [&nodes_wallets] (nano::block_hash const & hash_a) { return std::all_of (nodes_wallets.begin (), nodes_wallets.end (), [hash = hash_a] (auto const & node_wallet) { @@ -2146,7 +2146,7 @@ TEST (node, wallet_create_block_confirm_conflicts) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); latest = send->hash (); } } diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index a3337bc925..235367453e 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -13,7 +13,7 @@ nano::test::context::ledger_context::ledger_context (std::deque nano::test::system::add_node (nano::node_config cons for (auto i : initialization_blocks) { auto result = node->ledger.process (node->store.tx_begin_write (), *i); - debug_assert (result.code == nano::process_result::progress); + debug_assert (result == nano::block_status::progress); } debug_assert (!node->init_error ()); auto wallet = node->wallets.create (nano::random_wallet_id ()); @@ -262,7 +262,7 @@ std::unique_ptr nano::test::upgrade_epoch (nano::work_pool & bool error{ true }; if (!ec && epoch) { - error = ledger_a.process (transaction, *epoch).code != nano::process_result::progress; + error = ledger_a.process (transaction, *epoch) != nano::block_status::progress; } return !error ? std::move (epoch) : nullptr; diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 72cb4e212f..d08ca37b5f 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -65,7 +65,7 @@ bool nano::test::process (nano::node & node, std::vector Date: Mon, 19 Feb 2024 20:08:45 +0000 Subject: [PATCH 098/190] Constructing blocks in tests using shared_ptr --- nano/qt_test/qt.cpp | 80 ++++++++++++++++++++++----------------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index e1750a9ae3..df9cd9b767 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -422,10 +422,10 @@ TEST (wallet, create_send) std::stringstream istream (json); boost::property_tree::read_json (istream, tree1); bool error (false); - nano::state_block send (error, tree1); + auto send = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (send)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*send)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*send)); } TEST (wallet, create_open_receive) @@ -456,10 +456,10 @@ TEST (wallet, create_open_receive) std::stringstream istream1 (json1); boost::property_tree::read_json (istream1, tree1); bool error (false); - nano::state_block open (error, tree1); + auto open = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*open)); wallet->block_creation.block->clear (); wallet->block_creation.source->clear (); wallet->block_creation.receive->click (); @@ -471,10 +471,10 @@ TEST (wallet, create_open_receive) std::stringstream istream2 (json2); boost::property_tree::read_json (istream2, tree2); bool error2 (false); - nano::state_block receive (error2, tree2); + auto receive = std::make_shared (error2, tree2); ASSERT_FALSE (error2); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (receive)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*receive)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*receive)); } TEST (wallet, create_change) @@ -499,10 +499,10 @@ TEST (wallet, create_change) std::stringstream istream (json); boost::property_tree::read_json (istream, tree1); bool error (false); - nano::state_block change (error, tree1); + auto change = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (change)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*change)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*change)); } TEST (history, short_text) @@ -531,12 +531,12 @@ TEST (history, short_text) store->initialize (transaction, ledger.cache, ledger.constants); nano::keypair key; auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); - nano::send_block send (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); - nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); - nano::change_block change (receive.hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive.hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); + auto send = std::make_shared (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + auto receive = std::make_shared (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + auto change = std::make_shared (receive->hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive->hash ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); } nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet); history.refresh (); @@ -571,16 +571,16 @@ TEST (history, pruned_source) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); - nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - nano::send_block send2 (send1.hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); - nano::receive_block receive (send2.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); - nano::open_block open (send2.hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); - ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 2)); - next_pruning = send2.hash (); + auto send1 = std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + auto send2 = std::make_shared (send1->hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + auto receive = std::make_shared (send2->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + auto open = std::make_shared (send2->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 2)); + next_pruning = send2->hash (); } nano_qt::history history1 (ledger, nano::dev::genesis_key.pub, *wallet); history1.refresh (); @@ -601,11 +601,11 @@ TEST (history, pruned_source) { auto transaction (store->tx_begin_write ()); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); - nano::state_block send (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + auto send = std::make_shared (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); auto latest_key (ledger.latest (transaction, key.pub)); - nano::state_block receive (key.pub, latest_key, key.pub, 200, send.hash (), key.prv, key.pub, *system.work.generate (latest_key)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); + auto receive = std::make_shared (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest, 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 2)); } @@ -716,9 +716,9 @@ TEST (wallet, republish) { auto transaction (system.nodes[0]->store.tx_begin_write ()); auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); - nano::send_block block (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - hash = block.hash (); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block)); + auto block = std::make_shared (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + hash = block->hash (); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, *block)); } auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); @@ -916,8 +916,8 @@ TEST (wallet, DISABLED_synchronizing) { auto transaction (system1.nodes[0]->store.tx_begin_write ()); auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); - nano::send_block send (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); - system1.nodes[0]->ledger.process (transaction, send); + auto send = std::make_shared (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); + system1.nodes[0]->ledger.process (transaction, *send); } ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing)); system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ()); @@ -965,10 +965,10 @@ TEST (wallet, epoch_2_validation) std::stringstream istream (json); boost::property_tree::read_json (istream, tree1); bool error (false); - nano::state_block block (error, tree1); + auto block = std::make_shared (error, tree1); EXPECT_FALSE (error); - EXPECT_EQ (nano::block_status::progress, node->process (block)); - return block.hash (); + EXPECT_EQ (nano::block_status::progress, node->process (*block)); + return block->hash (); }; auto do_send = [&] (nano::public_key const & destination) -> nano::block_hash { From 6a663a4a09b756e7b1179b01f615a6f2d8997606 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Mon, 19 Feb 2024 19:17:21 +0000 Subject: [PATCH 099/190] Remove block_builder unique_ptr overloads and only build shared_ptr blocks. --- nano/core_test/active_transactions.cpp | 96 +++++----- nano/core_test/block.cpp | 14 +- nano/core_test/block_store.cpp | 2 +- nano/core_test/blockprocessor.cpp | 2 +- nano/core_test/bootstrap.cpp | 152 +++++++-------- nano/core_test/bootstrap_ascending.cpp | 10 +- nano/core_test/confirmation_height.cpp | 88 ++++----- nano/core_test/confirmation_solicitor.cpp | 6 +- nano/core_test/conflicts.cpp | 16 +- nano/core_test/election.cpp | 22 +-- nano/core_test/election_scheduler.cpp | 12 +- nano/core_test/ledger.cpp | 74 ++++---- nano/core_test/message.cpp | 4 +- nano/core_test/message_deserializer.cpp | 4 +- nano/core_test/network.cpp | 18 +- nano/core_test/network_filter.cpp | 4 +- nano/core_test/node.cpp | 220 +++++++++++----------- nano/core_test/request_aggregator.cpp | 28 +-- nano/core_test/scheduler_buckets.cpp | 10 +- nano/core_test/system.cpp | 4 +- nano/core_test/unchecked_map.cpp | 16 +- nano/core_test/voting.cpp | 8 +- nano/core_test/websocket.cpp | 28 +-- nano/lib/blockbuilders.cpp | 16 +- nano/lib/blockbuilders.hpp | 12 +- nano/rpc_test/rpc.cpp | 90 ++++----- nano/slow_test/node.cpp | 32 ++-- nano/slow_test/vote_cache.cpp | 8 +- nano/test_common/chains.cpp | 14 +- nano/test_common/ledger.cpp | 8 +- nano/test_common/system.cpp | 8 +- nano/test_common/system.hpp | 4 +- 32 files changed, 507 insertions(+), 523 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index e22cbba546..b984e38bfb 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -39,7 +39,7 @@ TEST (active_transactions, confirm_election_by_request) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Process send1 locally on node1 ASSERT_TRUE (nano::test::process (node1, { send1 })); @@ -115,7 +115,7 @@ TEST (active_transactions, confirm_frontier) .link (nano::public_key ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); { // Voting node @@ -127,7 +127,7 @@ TEST (active_transactions, confirm_frontier) system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // we cannot use the same block instance on 2 different nodes, so make a copy - auto send_copy = builder.make_block ().from (*send).build_shared (); + auto send_copy = builder.make_block ().from (*send).build (); ASSERT_TRUE (nano::test::process (node1, { send_copy })); ASSERT_TRUE (nano::test::start_elections (system, node1, { send_copy })); ASSERT_TIMELY (5s, nano::test::confirmed (node1, { send_copy })); @@ -216,7 +216,7 @@ TEST (active_transactions, keep_local) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); const auto receive2 = builder.make_block () .account (key2.pub) .previous (0) @@ -225,7 +225,7 @@ TEST (active_transactions, keep_local) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); const auto receive3 = builder.make_block () .account (key3.pub) .previous (0) @@ -234,7 +234,7 @@ TEST (active_transactions, keep_local) .link (send3->hash ()) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3.pub)) - .build_shared (); + .build (); node.process_active (receive1); node.process_active (receive2); node.process_active (receive3); @@ -256,7 +256,7 @@ TEST (active_transactions, inactive_votes_cache) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send }); node.vote_processor.vote (vote, std::make_shared (node, node)); ASSERT_TIMELY_EQ (5s, node.vote_cache.size (), 1); @@ -279,7 +279,7 @@ TEST (active_transactions, inactive_votes_cache_non_final) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Non-final vote auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send->hash ())); @@ -309,7 +309,7 @@ TEST (active_transactions, inactive_votes_cache_fork) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (latest) @@ -317,7 +317,7 @@ TEST (active_transactions, inactive_votes_cache_fork) .balance (nano::dev::constants.genesis_amount - 200) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto const vote = nano::test::make_final_vote (nano::dev::genesis_key, { send1 }); node.vote_processor.vote (vote, std::make_shared (node, node)); @@ -349,7 +349,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) .balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto open = builder.state () .account (key.pub) .previous (0) @@ -358,7 +358,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) .link (send->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); node.process_active (send); node.block_processor.add (open); ASSERT_TIMELY_EQ (5s, node.active.size (), 1); @@ -404,7 +404,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) .balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.send () .previous (send1->hash ()) @@ -412,7 +412,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) .balance (100 * nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); auto open = builder.state () .account (key1.pub) @@ -422,7 +422,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); // put the blocks in the ledger witout triggering an election ASSERT_TRUE (nano::test::process (node, { send1, send2, open })); @@ -464,14 +464,14 @@ TEST (active_transactions, inactive_votes_cache_election_start) .balance (nano::dev::constants.genesis_amount - amount) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto send2 = send_block_builder.make_block () .previous (send1->hash ()) .destination (key2.pub) .balance (nano::dev::constants.genesis_amount - 2 * amount) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); auto open1 = state_block_builder.make_block () .account (key1.pub) .previous (0) @@ -480,7 +480,7 @@ TEST (active_transactions, inactive_votes_cache_election_start) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); auto open2 = state_block_builder.make_block () .account (key2.pub) .previous (0) @@ -489,7 +489,7 @@ TEST (active_transactions, inactive_votes_cache_election_start) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send1)); ASSERT_EQ (nano::block_status::progress, node.process (*send2)); ASSERT_EQ (nano::block_status::progress, node.process (*open1)); @@ -504,14 +504,14 @@ TEST (active_transactions, inactive_votes_cache_election_start) .balance (send2->balance ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); + .build (); auto send4 = send_block_builder.make_block () .previous (send3->hash ()) .destination (nano::keypair ().pub) .balance (send3->balance ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) - .build_shared (); + .build (); // Inactive votes auto vote1 = nano::test::make_vote (key1, { open1, open2, send4 }); @@ -569,7 +569,7 @@ TEST (active_transactions, vote_replays) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_NE (nullptr, send1); // create open block for key receing Gxrb_ratio raw @@ -581,7 +581,7 @@ TEST (active_transactions, vote_replays) .link (send1->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_NE (nullptr, open1); // wait for elections objects to appear in the AEC @@ -616,7 +616,7 @@ TEST (active_transactions, vote_replays) .link (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (open1->hash ())) - .build_shared (); + .build (); ASSERT_NE (nullptr, send2); node.process_active (send2); ASSERT_TRUE (nano::test::start_elections (system, node, { send2 })); @@ -726,7 +726,7 @@ TEST (active_transactions, republish_winner) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send1); ASSERT_TIMELY (5s, nano::test::exists (node1, { send1 })); @@ -743,7 +743,7 @@ TEST (active_transactions, republish_winner) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (fork); ASSERT_TIMELY (5s, node1.active.active (*fork)); } @@ -759,7 +759,7 @@ TEST (active_transactions, republish_winner) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (fork); ASSERT_TIMELY (5s, node1.active.active (fork->hash ())); @@ -793,7 +793,7 @@ TEST (active_transactions, fork_filter_cleanup) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); std::vector send_block_bytes{}; { @@ -812,7 +812,7 @@ TEST (active_transactions, fork_filter_cleanup) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (fork); ASSERT_TIMELY (5s, node1.active.election (fork->qualified_root ()) != nullptr); @@ -882,7 +882,7 @@ TEST (active_transactions, fork_replacement_tally) .link (keys[i].pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); node1.process_active (send); latest = send->hash (); auto open = builder.make_block () @@ -893,7 +893,7 @@ TEST (active_transactions, fork_replacement_tally) .link (send->hash ()) .sign (keys[i].prv, keys[i].pub) .work (*system.work.generate (keys[i].pub)) - .build_shared (); + .build (); node1.process_active (open); // Confirmation auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send, open }); @@ -910,7 +910,7 @@ TEST (active_transactions, fork_replacement_tally) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); // Forks without votes for (auto i (0); i < reps_count; i++) @@ -923,7 +923,7 @@ TEST (active_transactions, fork_replacement_tally) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); node1.process_active (fork); } @@ -943,7 +943,7 @@ TEST (active_transactions, fork_replacement_tally) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto vote = nano::test::make_vote (keys[i], { fork }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1, node1)); node1.vote_processor.flush (); @@ -1051,7 +1051,7 @@ TEST (active_transactions, confirm_new) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); auto & node2 = *system.add_node (); @@ -1081,7 +1081,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto fork = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -1090,7 +1090,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto vote_fork = nano::test::make_final_vote (nano::dev::genesis_key, { fork }); ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ()); @@ -1226,7 +1226,7 @@ TEST (active_transactions, activate_inactive) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send->hash ()) @@ -1235,7 +1235,7 @@ TEST (active_transactions, activate_inactive) .balance (nano::dev::constants.genesis_amount - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); auto open = builder.make_block () .account (key.pub) .previous (0) @@ -1244,7 +1244,7 @@ TEST (active_transactions, activate_inactive) .balance (1) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send)); ASSERT_EQ (nano::block_status::progress, node.process (*send2)); @@ -1281,7 +1281,7 @@ TEST (active_transactions, list_active) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send)); @@ -1293,7 +1293,7 @@ TEST (active_transactions, list_active) .balance (nano::dev::constants.genesis_amount - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send2)); @@ -1305,7 +1305,7 @@ TEST (active_transactions, list_active) .balance (1) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*open)); @@ -1338,7 +1338,7 @@ TEST (active_transactions, vacancy) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node.active.vacancy_update = [&updated] () { updated = true; }; ASSERT_EQ (nano::block_status::progress, node.process (*send)); ASSERT_EQ (1, node.active.vacancy ()); @@ -1380,7 +1380,7 @@ TEST (active_transactions, fifo) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send1)); node.process_confirmed (nano::election_status{ send1 }); ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ())); @@ -1395,7 +1395,7 @@ TEST (active_transactions, fifo) .balance (nano::dev::constants.genesis_amount - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send2)); node.process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ())); @@ -1408,7 +1408,7 @@ TEST (active_transactions, fifo) .balance (1) .sign (key0.prv, key0.pub) .work (*system.work.generate (key0.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*receive1)); auto receive2 = builder.make_block () @@ -1419,7 +1419,7 @@ TEST (active_transactions, fifo) .balance (1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*receive2)); // Ensure first transaction becomes active diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 7a2c37b812..2b66920826 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -385,7 +385,7 @@ TEST (block, publish_req_serialization) .balance (200) .sign (nano::keypair ().prv, 2) .work (3) - .build_shared (); + .build (); nano::publish req{ nano::dev::network_params.network, block }; std::vector bytes; { @@ -429,7 +429,7 @@ TEST (state_block, serialization) .link (4) .sign (key1.prv, key1.pub) .work (5) - .build_shared (); + .build (); ASSERT_EQ (key1.pub, block1->hashables.account); ASSERT_EQ (nano::block_hash (1), block1->previous ()); ASSERT_EQ (key2.pub, block1->hashables.representative); @@ -489,7 +489,7 @@ TEST (state_block, hashing) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); auto hash (block->hash ()); ASSERT_EQ (hash, block->hash ()); // check cache works block->hashables.account.bytes[0] ^= 0x1; @@ -551,7 +551,7 @@ TEST (block_uniquer, single) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); auto block2 (std::make_shared (*block1)); ASSERT_NE (block1, block2); ASSERT_EQ (*block1, *block2); @@ -578,7 +578,7 @@ TEST (block_uniquer, cleanup) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); auto block2 = builder .make_block () .account (0) @@ -588,7 +588,7 @@ TEST (block_uniquer, cleanup) .link (0) .sign (key.prv, key.pub) .work (1) - .build_shared (); + .build (); nano::block_uniquer uniquer; auto block3 = uniquer.unique (block1); @@ -636,7 +636,7 @@ TEST (block_builder, zeroed_state_block) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); auto zero_block_build = builder.state ().zero ().sign (key.prv, key.pub).build (); ASSERT_EQ (zero_block_manual->hash (), zero_block_build->hash ()); ASSERT_FALSE (nano::validate_message (key.pub, zero_block_build->hash (), zero_block_build->signature)); diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index fd4c78049d..c56946267d 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1673,7 +1673,7 @@ TEST (rocksdb_block_store, tombstone_count) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); // Enqueues a block to be saved in the database nano::account account{ 1 }; store->account.put (store->tx_begin_write (), account, nano::account_info{}); diff --git a/nano/core_test/blockprocessor.cpp b/nano/core_test/blockprocessor.cpp index 9bcc43a048..38ccdc65b4 100644 --- a/nano/core_test/blockprocessor.cpp +++ b/nano/core_test/blockprocessor.cpp @@ -32,7 +32,7 @@ TEST (block_processor, broadcast_block_on_arrival) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Adds a block to the first node. process_active() -> (calls) block_processor.add() -> add() -> // awakes process_block() -> process_batch() -> process_one() -> process_live() node1->process_active (send1); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 1003a01f91..485e49a055 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -120,7 +120,7 @@ TEST (bulk_pull, ascending_one_hash) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); @@ -152,7 +152,7 @@ TEST (bulk_pull, ascending_two_account) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); @@ -187,7 +187,7 @@ TEST (bulk_pull, ascending_end) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (*block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); @@ -248,7 +248,7 @@ TEST (bulk_pull, count_limit) .balance (1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); auto receive1 = builder .receive () @@ -256,7 +256,7 @@ TEST (bulk_pull, count_limit) .source (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*receive1)); auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket::endpoint_type_t::server), node0)); @@ -361,7 +361,7 @@ TEST (bootstrap_processor, process_state) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); auto block2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -371,7 +371,7 @@ TEST (bootstrap_processor, process_state) .link (block1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block2); @@ -443,7 +443,7 @@ TEST (bootstrap_processor, pull_diamond) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); auto open = builder .open () @@ -452,7 +452,7 @@ TEST (bootstrap_processor, pull_diamond) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*open)); auto send2 = builder .send () @@ -461,7 +461,7 @@ TEST (bootstrap_processor, pull_diamond) .balance (std::numeric_limits::max () - 100) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*send2)); auto receive = builder .receive () @@ -469,7 +469,7 @@ TEST (bootstrap_processor, pull_diamond) .source (send2->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*receive)); auto node1 = system.make_disconnected_node (); @@ -501,7 +501,7 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1->bootstrap_initiator.bootstrap (node2->network.endpoint ()); auto attempt (node1->bootstrap_initiator.current_attempt ()); @@ -540,7 +540,7 @@ TEST (bootstrap_processor, push_diamond) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // open key account receiving all balance of genesis @@ -551,7 +551,7 @@ TEST (bootstrap_processor, push_diamond) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // send from key to genesis 100 raw @@ -562,7 +562,7 @@ TEST (bootstrap_processor, push_diamond) .balance (std::numeric_limits::max () - 100) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive the 100 raw on genesis @@ -572,7 +572,7 @@ TEST (bootstrap_processor, push_diamond) .source (send2->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); nano::node_config config = system.default_config (); @@ -613,7 +613,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // receive all balance on key @@ -624,7 +624,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // 1st bootstrap @@ -642,7 +642,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .balance (std::numeric_limits::max () - 100) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive the 100 raw from key on genesis @@ -652,7 +652,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .source (send2->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); { @@ -722,7 +722,7 @@ TEST (bootstrap_processor, lazy_hash) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -732,7 +732,7 @@ TEST (bootstrap_processor, lazy_hash) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -742,7 +742,7 @@ TEST (bootstrap_processor, lazy_hash) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); auto receive2 = builder .make_block () .account (key2.pub) @@ -752,7 +752,7 @@ TEST (bootstrap_processor, lazy_hash) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); // Processing test chain node0->block_processor.add (send1); @@ -797,7 +797,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -807,7 +807,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -817,7 +817,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); auto receive2 = builder .make_block () .account (key2.pub) @@ -827,7 +827,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); // Processing test chain node0->block_processor.add (send1); @@ -872,7 +872,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // receive send1 auto receive1 = builder @@ -884,7 +884,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); // change rep of genesis account to be key1 nano::keypair key1; @@ -897,7 +897,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); // change rep of genesis account to be rep2 nano::keypair key2; @@ -910,7 +910,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change1->hash ())) - .build_shared (); + .build (); // send Gxrb_ratio from genesis to key1 and genesis rep back to genesis account auto send2 = builder @@ -922,7 +922,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change2->hash ())) - .build_shared (); + .build (); // receive send2 and rep of key1 to be itself auto receive2 = builder @@ -934,7 +934,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (send2->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); // send Gxrb_ratio raw, all available balance, from key1 to key2 auto send3 = builder @@ -946,7 +946,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive2->hash ())) - .build_shared (); + .build (); // receive send3 on key2, set rep of key2 to be itself auto receive3 = builder @@ -958,7 +958,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) .link (send3->hash ()) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); std::vector> blocks = { send1, receive1, change1, change2, send2, receive2, send3, receive3 }; ASSERT_TRUE (nano::test::process (*node0, blocks)); @@ -1025,7 +1025,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -1035,7 +1035,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -1045,7 +1045,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); auto receive2 = builder .make_block () .account (key2.pub) @@ -1055,7 +1055,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); auto change1 = builder .make_block () .account (key2.pub) @@ -1065,7 +1065,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (0) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (receive2->hash ())) - .build_shared (); + .build (); auto change2 = builder .make_block () .account (key2.pub) @@ -1075,7 +1075,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (0) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (change1->hash ())) - .build_shared (); + .build (); auto change3 = builder .make_block () .account (key2.pub) @@ -1085,7 +1085,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .link (0) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (change2->hash ())) - .build_shared (); + .build (); // Processing test chain node0->block_processor.add (send1); node0->block_processor.add (receive1); @@ -1129,7 +1129,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto send2 = builder .state () @@ -1140,7 +1140,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); auto open = builder .open () @@ -1149,7 +1149,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto receive = builder .state () @@ -1160,7 +1160,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .link (send2->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive })); @@ -1199,7 +1199,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto open = builder .open () @@ -1208,7 +1208,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); auto send2 = builder .state () @@ -1219,7 +1219,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .link (key2.pub) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // Start lazy bootstrap with last block in chain known @@ -1258,7 +1258,7 @@ TEST (bootstrap_processor, lazy_destinations) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); // send Gxrb_ratio raw from genesis to key2 @@ -1271,7 +1271,7 @@ TEST (bootstrap_processor, lazy_destinations) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); // receive send1 on key1 @@ -1282,7 +1282,7 @@ TEST (bootstrap_processor, lazy_destinations) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // receive send2 on key2 @@ -1295,7 +1295,7 @@ TEST (bootstrap_processor, lazy_destinations) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*state_open)); // Start lazy bootstrap with last block in sender chain @@ -1339,7 +1339,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1->process_active (send1); // send from genesis to key2 @@ -1352,7 +1352,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); node1->process_active (send2); // open account key1 @@ -1363,7 +1363,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); node1->process_active (open); // open account key2 @@ -1376,7 +1376,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); node1->process_active (state_open); ASSERT_TIMELY (5s, node1->block (state_open->hash ()) != nullptr); @@ -1440,7 +1440,7 @@ TEST (bootstrap_processor, lazy_cancel) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Start lazy bootstrap with last block in chain known auto node1 = system.make_disconnected_node (); @@ -1481,7 +1481,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -1491,7 +1491,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -1501,7 +1501,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); auto receive2 = builder .make_block () .account (key2.pub) @@ -1511,7 +1511,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node0->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); // Processing test chain node0->block_processor.add (send1); @@ -1562,7 +1562,7 @@ TEST (bootstrap_processor, wallet_lazy_pending) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -1572,7 +1572,7 @@ TEST (bootstrap_processor, wallet_lazy_pending) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -1582,7 +1582,7 @@ TEST (bootstrap_processor, wallet_lazy_pending) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node0->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); // Processing test chain node0->block_processor.add (send1); @@ -1623,7 +1623,7 @@ TEST (bootstrap_processor, multiple_attempts) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder .make_block () .account (key1.pub) @@ -1633,7 +1633,7 @@ TEST (bootstrap_processor, multiple_attempts) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node1->work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .make_block () .account (key1.pub) @@ -1643,7 +1643,7 @@ TEST (bootstrap_processor, multiple_attempts) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*node1->work_generate_blocking (receive1->hash ())) - .build_shared (); + .build (); auto receive2 = builder .make_block () .account (key2.pub) @@ -1653,7 +1653,7 @@ TEST (bootstrap_processor, multiple_attempts) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node1->work_generate_blocking (key2.pub)) - .build_shared (); + .build (); // Processing test chain node1->block_processor.add (send1); @@ -1742,7 +1742,7 @@ TEST (frontier_req, count) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*send1); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto receive1 = builder @@ -1754,7 +1754,7 @@ TEST (frontier_req, count) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*receive1); ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); @@ -1837,7 +1837,7 @@ TEST (frontier_req, confirmed_frontier) .link (key_before_genesis.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*send1); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto send2 = builder @@ -1849,7 +1849,7 @@ TEST (frontier_req, confirmed_frontier) .link (key_after_genesis.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*send2); ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); auto receive1 = builder @@ -1861,7 +1861,7 @@ TEST (frontier_req, confirmed_frontier) .link (send1->hash ()) .sign (key_before_genesis.prv, key_before_genesis.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*receive1); ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); auto receive2 = builder @@ -1873,7 +1873,7 @@ TEST (frontier_req, confirmed_frontier) .link (send2->hash ()) .sign (key_after_genesis.prv, key_after_genesis.pub) .work (0) - .build_shared (); + .build (); node1->work_generate_blocking (*receive2); ASSERT_EQ (nano::block_status::progress, node1->process (*receive2)); diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index 3f8059cdd1..914c58c6b5 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -170,7 +170,7 @@ TEST (bootstrap_ascending, account_base) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); @@ -193,7 +193,7 @@ TEST (bootstrap_ascending, account_inductive) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) @@ -202,7 +202,7 @@ TEST (bootstrap_ascending, account_inductive) .balance (nano::dev::constants.genesis_amount - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); // std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl; // std::cerr << "Send1: " << send1->hash ().to_string () << std::endl; // std::cerr << "Send2: " << send2->hash ().to_string () << std::endl; @@ -231,7 +231,7 @@ TEST (bootstrap_ascending, trace_base) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder.make_block () .account (key.pub) .previous (0) @@ -240,7 +240,7 @@ TEST (bootstrap_ascending, trace_base) .balance (1) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); // std::cerr << "Genesis key: " << nano::dev::genesis_key.pub.to_account () << std::endl; // std::cerr << "Key: " << key.pub.to_account () << std::endl; // std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index c832b3f2d1..8027db461d 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -50,7 +50,7 @@ TEST (confirmation_height, single) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest1)) - .build_shared (); + .build (); // Check confirmation heights before, should be uninitialized (1 for genesis). nano::confirmation_height_info confirmation_height_info; @@ -238,7 +238,7 @@ TEST (confirmation_height, multiple_accounts) .source (send6->hash ()) .sign (key3.prv, key3.pub) .work (*system.work.generate (open3->hash ())) - .build_shared (); + .build (); node->process_active (receive3); auto election = nano::test::start_election (system, *node, receive3->hash ()); ASSERT_NE (nullptr, election); @@ -326,7 +326,7 @@ TEST (confirmation_height, gap_bootstrap) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto send2 = builder .state () @@ -337,7 +337,7 @@ TEST (confirmation_height, gap_bootstrap) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); auto send3 = builder .state () @@ -348,7 +348,7 @@ TEST (confirmation_height, gap_bootstrap) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send3); auto open1 = builder .open () @@ -357,7 +357,7 @@ TEST (confirmation_height, gap_bootstrap) .account (destination.pub) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open1); // Receive @@ -367,7 +367,7 @@ TEST (confirmation_height, gap_bootstrap) .source (send2->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*receive1); auto receive2 = builder .receive () @@ -375,7 +375,7 @@ TEST (confirmation_height, gap_bootstrap) .source (send3->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*receive2); node1.block_processor.add (send1); @@ -459,7 +459,7 @@ TEST (confirmation_height, gap_live) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*send1); auto send2 = builder .state () @@ -470,7 +470,7 @@ TEST (confirmation_height, gap_live) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*send2); auto send3 = builder .state () @@ -481,7 +481,7 @@ TEST (confirmation_height, gap_live) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*send3); auto open1 = builder @@ -491,7 +491,7 @@ TEST (confirmation_height, gap_live) .account (destination.pub) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*open1); auto receive1 = builder .receive () @@ -499,7 +499,7 @@ TEST (confirmation_height, gap_live) .source (send2->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*receive1); auto receive2 = builder .receive () @@ -507,7 +507,7 @@ TEST (confirmation_height, gap_live) .source (send3->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node->work_generate_blocking (*receive2); node->block_processor.add (send1); @@ -656,7 +656,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) .source (send5->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (send4->hash ())) - .build_shared (); + .build (); nano::keypair key2; auto send6 = builder .send () @@ -749,7 +749,7 @@ TEST (confirmation_height, send_receive_self) .source (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); auto send2 = builder .send () .previous (receive1->hash ()) @@ -779,7 +779,7 @@ TEST (confirmation_height, send_receive_self) .source (send3->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (receive2->hash ())) - .build_shared (); + .build (); // Send to another account to prevent automatic receiving on the genesis account nano::keypair key1; @@ -988,7 +988,7 @@ TEST (confirmation_height, all_block_types) .link (key1.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (state_receive2->hash ())) - .build_shared (); + .build (); auto state_send3 = builder .state () .account (key2.pub) @@ -1116,7 +1116,7 @@ TEST (confirmation_height, conflict_rollback_cemented) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_hash)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a)); ASSERT_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true)); ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a })); @@ -1131,7 +1131,7 @@ TEST (confirmation_height, conflict_rollback_cemented) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_hash)) - .build_shared (); + .build (); node1->block_processor.force (fork1b); // node2 already has send2 forced confirmed whilst node1 should have confirmed send1 and therefore we have a cemented fork on node2 @@ -1175,7 +1175,7 @@ TEST (confirmation_heightDeathTest, rollback_added_block) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -1215,7 +1215,7 @@ TEST (confirmation_height, observers) .balance (amount - node1->config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest1)) - .build_shared (); + .build (); add_callback_stats (*node1); @@ -1265,7 +1265,7 @@ TEST (confirmation_heightDeathTest, modified_chain) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -1342,7 +1342,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto open = builder .state () .account (key1.pub) @@ -1352,7 +1352,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) .link (send->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -1430,7 +1430,7 @@ TEST (confirmation_height, pending_observer_callbacks) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); @@ -1479,7 +1479,7 @@ TEST (confirmation_height, callback_confirmed_history) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); @@ -1492,7 +1492,7 @@ TEST (confirmation_height, callback_confirmed_history) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); add_callback_stats (*node); @@ -1567,7 +1567,7 @@ TEST (confirmation_height, dependent_election) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto send1 = builder .send () .previous (send->hash ()) @@ -1575,7 +1575,7 @@ TEST (confirmation_height, dependent_election) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); auto send2 = builder .send () .previous (send1->hash ()) @@ -1583,7 +1583,7 @@ TEST (confirmation_height, dependent_election) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); @@ -1725,7 +1725,7 @@ TEST (confirmation_height, cemented_gap_below_receive) .account (key2.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); @@ -1885,7 +1885,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) .account (key2.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); @@ -1958,7 +1958,7 @@ TEST (confirmation_height, election_winner_details_clearing) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto const send2 = builder.make_block () @@ -1967,7 +1967,7 @@ TEST (confirmation_height, election_winner_details_clearing) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto const send3 = builder.make_block () @@ -1976,7 +1976,7 @@ TEST (confirmation_height, election_winner_details_clearing) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->process (*send3)); node->process_confirmed (nano::election_status{ send2 }); @@ -2016,7 +2016,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Add to election_winner_details. Use an unrealistic iteration so that it should fall into the else case and do a cleanup node->active.add_election_winner_details (send->hash (), nullptr); nano::election_status election; @@ -2050,7 +2050,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send1 = builder .send () .previous (send->hash ()) @@ -2058,7 +2058,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) - .build_shared (); + .build (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); @@ -2115,7 +2115,7 @@ TEST (confirmation_height, pruned_source) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto open1 = builder .state () .account (key1.pub) @@ -2125,7 +2125,7 @@ TEST (confirmation_height, pruned_source) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); auto send2 = builder .state () .account (key1.pub) @@ -2135,7 +2135,7 @@ TEST (confirmation_height, pruned_source) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*pool.generate (open1->hash ())) - .build_shared (); + .build (); auto send3 = builder .state () .account (key1.pub) @@ -2145,7 +2145,7 @@ TEST (confirmation_height, pruned_source) .link (key2.pub) .sign (key1.prv, key1.pub) .work (*pool.generate (send2->hash ())) - .build_shared (); + .build (); auto open2 = builder .state () .account (key2.pub) @@ -2155,7 +2155,7 @@ TEST (confirmation_height, pruned_source) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) - .build_shared (); + .build (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index c456624153..c47ae54e88 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -37,7 +37,7 @@ TEST (confirmation_solicitor, batches) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); send->sideband_set ({}); { nano::lock_guard guard (node2.active.mutex); @@ -87,7 +87,7 @@ TEST (confirmation_solicitor, different_hash) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); send->sideband_set ({}); auto election (std::make_shared (node2, send, nullptr, nullptr, nano::election_behavior::normal)); // Add a vote for something else, not the winner @@ -131,7 +131,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); send->sideband_set ({}); auto election (std::make_shared (node2, send, nullptr, nullptr, nano::election_behavior::normal)); // Add a vote for something else, not the winner diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 8ee21c4dba..a670b37770 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -25,7 +25,7 @@ TEST (conflicts, start_stop) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); ASSERT_EQ (0, node1.active.size ()); @@ -52,7 +52,7 @@ TEST (conflicts, add_existing) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); // add the block to ledger as an unconfirmed block @@ -75,7 +75,7 @@ TEST (conflicts, add_existing) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); send2->sideband_set ({}); @@ -108,7 +108,7 @@ TEST (conflicts, add_two) .link (key3.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) - .build_shared (); + .build (); // send 1 raw to account key3 from key2 auto send_b = nano::state_block_builder () @@ -119,7 +119,7 @@ TEST (conflicts, add_two) .link (key3.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (open2->hash ())) - .build_shared (); + .build (); // activate elections for the previous two send blocks (to account3) that we did not forcefully confirm ASSERT_TRUE (nano::test::process (*node, { send_a, send_b })); @@ -149,7 +149,7 @@ TEST (vote_uniquer, vbh_one) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); std::vector hashes; hashes.push_back (block->hash ()); auto vote1 = nano::test::make_vote (key, { hashes }, 0, 0); @@ -172,7 +172,7 @@ TEST (vote_uniquer, vbh_two) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); std::vector hashes1; hashes1.push_back (block1->hash ()); auto block2 = builder @@ -184,7 +184,7 @@ TEST (vote_uniquer, vbh_two) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); std::vector hashes2; hashes2.push_back (block2->hash ()); auto vote1 = nano::test::make_vote (key, { hashes1 }, 0, 0); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 52ffa5e8d2..cfd4344380 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -47,7 +47,7 @@ TEST (election, quorum_minimum_flip_success) .link (key1.pub) .work (*system.work.generate (latest_hash)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); nano::keypair key2{}; auto send2 = builder.make_block () @@ -58,7 +58,7 @@ TEST (election, quorum_minimum_flip_success) .link (key2.pub) .work (*system.work.generate (latest_hash)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); node1.process_active (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()) != nullptr) @@ -94,7 +94,7 @@ TEST (election, quorum_minimum_flip_fail) .link (nano::keypair{}.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) @@ -104,7 +104,7 @@ TEST (election, quorum_minimum_flip_fail) .link (nano::keypair{}.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); // process send1 and wait until its election appears node.process_active (send1); @@ -145,7 +145,7 @@ TEST (election, quorum_minimum_confirm_success) .link (key1.pub) .work (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); node1.process_active (send1); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); @@ -177,7 +177,7 @@ TEST (election, quorum_minimum_confirm_fail) .link (nano::keypair{}.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); node1.process_active (send1); auto election = nano::test::start_election (system, node1, send1->hash ()); @@ -219,11 +219,11 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) .balance (amount) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); node1.process_active (send1); ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); - auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build_shared (); + auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build (); ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); nano::keypair key2; @@ -233,7 +233,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) .balance (3) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4); @@ -283,7 +283,7 @@ TEST (election, continuous_voting) .balance (node1.balance (nano::dev::genesis_key.pub) / 10 * 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_TRUE (nano::test::process (node1, { send1 })); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1 }, true)); @@ -298,7 +298,7 @@ TEST (election, continuous_voting) .balance (node1.balance (nano::dev::genesis_key.pub) - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_TRUE (nano::test::process (node1, { send2 })); ASSERT_TIMELY (5s, node1.active.active (*send2)); diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index b13c3af776..db78e13681 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -26,7 +26,7 @@ TEST (election_scheduler, activate_one_timely) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); @@ -44,7 +44,7 @@ TEST (election_scheduler, activate_one_flush) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); @@ -86,7 +86,7 @@ TEST (election_scheduler, no_vacancy) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send)); node.process_confirmed (nano::election_status{ send }); @@ -98,7 +98,7 @@ TEST (election_scheduler, no_vacancy) .balance (nano::Gxrb_ratio) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*receive)); node.process_confirmed (nano::election_status{ receive }); @@ -111,7 +111,7 @@ TEST (election_scheduler, no_vacancy) .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*block1)); // There is vacancy so it should be inserted @@ -127,7 +127,7 @@ TEST (election_scheduler, no_vacancy) .balance (0) .sign (key.prv, key.pub) .work (*system.work.generate (receive->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*block2)); // There is no vacancy so it should stay queued diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index fd52883a67..983ed8c735 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -907,7 +907,7 @@ TEST (votes, check_signature) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); { auto transaction (node1.store.tx_begin_write ()); @@ -938,7 +938,7 @@ TEST (votes, add_one) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); @@ -1039,7 +1039,7 @@ TEST (votes, add_old) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); @@ -1057,7 +1057,7 @@ TEST (votes, add_old) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); auto vote2 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send2->hash () }); auto vote_info = election1->get_last_vote (nano::dev::genesis_key.pub); @@ -1089,7 +1089,7 @@ TEST (votes, DISABLED_add_old_different_account) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto send2 = builder .send () @@ -1098,7 +1098,7 @@ TEST (votes, DISABLED_add_old_different_account) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); @@ -1144,7 +1144,7 @@ TEST (votes, add_cooldown) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); @@ -1162,7 +1162,7 @@ TEST (votes, add_cooldown) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); auto vote2 = nano::test::make_vote (nano::dev::genesis_key, { send2 }, nano::vote::timestamp_min * 2, 0); node1.vote_processor.vote_blocking (vote2, channel); @@ -1277,7 +1277,7 @@ TEST (ledger, fail_epoch_bad_signature) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); block->signature.bytes[0] ^= 1; auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::block_status::bad_signature, result1); // Fails epoch signature @@ -4043,7 +4043,7 @@ TEST (ledger, epoch_open_pending) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); auto process_result = node1.ledger.process (node1.store.tx_begin_write (), *epoch_open); ASSERT_EQ (nano::block_status::gap_epoch_open_pending, process_result); node1.block_processor.add (epoch_open); @@ -4063,7 +4063,7 @@ TEST (ledger, epoch_open_pending) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.block_processor.add (send1); ASSERT_TIMELY (10s, node1.ledger.block_or_pruned_exists (epoch_open->hash ())); } @@ -4089,7 +4089,7 @@ TEST (ledger, block_hash_account_conflict) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto receive1 = builder.state () .account (key1.pub) @@ -4099,7 +4099,7 @@ TEST (ledger, block_hash_account_conflict) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); /* * Note that the below link is a block hash when this is intended @@ -4115,7 +4115,7 @@ TEST (ledger, block_hash_account_conflict) .link (receive1->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (receive1->hash ())) - .build_shared (); + .build (); /* * Generate an epoch open for the account with the same value as the block hash @@ -4129,7 +4129,7 @@ TEST (ledger, block_hash_account_conflict) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive1->hash ())) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); node1.work_generate_blocking (*receive1); @@ -4315,7 +4315,7 @@ TEST (ledger, unchecked_epoch) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto open1 = builder .state () @@ -4326,7 +4326,7 @@ TEST (ledger, unchecked_epoch) .link (send1->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open1); auto epoch1 = builder .state () @@ -4337,7 +4337,7 @@ TEST (ledger, unchecked_epoch) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*epoch1); node1.block_processor.add (epoch1); { @@ -4375,7 +4375,7 @@ TEST (ledger, unchecked_epoch_invalid) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto open1 = builder .state () @@ -4386,7 +4386,7 @@ TEST (ledger, unchecked_epoch_invalid) .link (send1->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open1); // Epoch block with account own signature auto epoch1 = builder @@ -4398,7 +4398,7 @@ TEST (ledger, unchecked_epoch_invalid) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*epoch1); // Pseudo epoch block (send subtype, destination - epoch link) auto epoch2 = builder @@ -4410,7 +4410,7 @@ TEST (ledger, unchecked_epoch_invalid) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*epoch2); node1.block_processor.add (epoch1); node1.block_processor.add (epoch2); @@ -4457,7 +4457,7 @@ TEST (ledger, unchecked_open) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto open1 = builder .open () @@ -4466,7 +4466,7 @@ TEST (ledger, unchecked_open) .account (destination.pub) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open1); // Invalid signature for open block auto open2 = builder @@ -4476,7 +4476,7 @@ TEST (ledger, unchecked_open) .account (destination.pub) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open2); open2->signature.bytes[0] ^= 1; node1.block_processor.add (open2); // Insert open2 in to the queue before open1 @@ -4509,7 +4509,7 @@ TEST (ledger, unchecked_receive) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto send2 = builder .state () @@ -4520,7 +4520,7 @@ TEST (ledger, unchecked_receive) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); auto open1 = builder .open () @@ -4529,7 +4529,7 @@ TEST (ledger, unchecked_receive) .account (destination.pub) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open1); auto receive1 = builder .receive () @@ -4537,7 +4537,7 @@ TEST (ledger, unchecked_receive) .source (send2->hash ()) .sign (destination.prv, destination.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*receive1); node1.block_processor.add (send1); node1.block_processor.add (receive1); @@ -4745,7 +4745,7 @@ TEST (ledger, dependents_confirmed) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () @@ -4756,7 +4756,7 @@ TEST (ledger, dependents_confirmed) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2)); auto receive1 = builder.state () @@ -4767,7 +4767,7 @@ TEST (ledger, dependents_confirmed) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; @@ -4783,7 +4783,7 @@ TEST (ledger, dependents_confirmed) .link (send2->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (receive1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); ASSERT_TRUE (ledger.store.confirmation_height.get (transaction, key1.pub, height)); @@ -4817,7 +4817,7 @@ TEST (ledger, dependents_confirmed_pruning) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) @@ -4827,7 +4827,7 @@ TEST (ledger, dependents_confirmed_pruning) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4843,7 +4843,7 @@ TEST (ledger, dependents_confirmed_pruning) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1)); } @@ -5601,7 +5601,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::endpoint_key endpoint_key (address.to_bytes (), port); auto version = nano::store::component::version_current; diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 024cf03f7f..102af44db8 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -20,7 +20,7 @@ std::shared_ptr random_block () .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); return block; } } @@ -818,4 +818,4 @@ TEST (handshake, signature_v2) message.v2->salt = nano::random_pool::generate (); ASSERT_FALSE (message.validate (cookie)); } -} \ No newline at end of file +} diff --git a/nano/core_test/message_deserializer.cpp b/nano/core_test/message_deserializer.cpp index 0954b2c0c4..271330491e 100644 --- a/nano/core_test/message_deserializer.cpp +++ b/nano/core_test/message_deserializer.cpp @@ -65,7 +65,7 @@ TEST (message_deserializer, exact_confirm_ack) .balance (2) .sign (nano::keypair ().prv, 4) .work (*system.work.generate (nano::root (1))) - .build_shared (); + .build (); auto vote (std::make_shared (0, nano::keypair ().prv, 0, 0, std::vector{ block->hash () })); nano::confirm_ack message{ nano::dev::network_params.network, vote }; @@ -101,7 +101,7 @@ TEST (message_deserializer, exact_publish) .balance (2) .sign (nano::keypair ().prv, 4) .work (*system.work.generate (nano::root (1))) - .build_shared (); + .build (); nano::publish message{ nano::dev::network_params.network, block }; message_deserializer_success_checker (message); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 98b8fedaa1..e3253fa32a 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -187,7 +187,7 @@ TEST (network, send_discarded_publish) .balance (2) .sign (nano::keypair ().prv, 4) .work (*system.work.generate (nano::root (1))) - .build_shared (); + .build (); { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); @@ -213,7 +213,7 @@ TEST (network, send_invalid_publish) .balance (20) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::root (1))) - .build_shared (); + .build (); { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); @@ -299,7 +299,7 @@ TEST (network, send_insufficient_work) .balance (20) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); nano::publish publish1{ nano::dev::network_params.network, block1 }; auto tcp_channel (node1.network.tcp_channels.find_node_id (node2.get_node_id ())); ASSERT_NE (nullptr, tcp_channel); @@ -315,7 +315,7 @@ TEST (network, send_insufficient_work) .balance (20) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)) - .build_shared (); + .build (); nano::publish publish2{ nano::dev::network_params.network, block2 }; tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1); @@ -328,7 +328,7 @@ TEST (network, send_insufficient_work) .balance (20) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block2->hash (), node1.network_params.work.epoch_2)) - .build_shared (); + .build (); nano::publish publish3{ nano::dev::network_params.network, block3 }; tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); @@ -344,7 +344,7 @@ TEST (network, send_insufficient_work) .link (1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)) - .build_shared (); + .build (); nano::publish publish4{ nano::dev::network_params.network, block4 }; tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); @@ -364,7 +364,7 @@ TEST (receivable_processor, confirm_insufficient_pos) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); @@ -387,7 +387,7 @@ TEST (receivable_processor, confirm_sufficient_pos) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); @@ -417,7 +417,7 @@ TEST (receivable_processor, send_with_receive) .balance (amount - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest1)) - .build_shared (); + .build (); ASSERT_EQ (amount, node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.balance (key2.pub)); ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub)); diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp index 21f6f7ec58..ae7f47e836 100644 --- a/nano/core_test/network_filter.cpp +++ b/nano/core_test/network_filter.cpp @@ -45,7 +45,7 @@ TEST (network_filter, unit) .link (nano::public_key ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); one_block (new_block, false); for (int i = 0; i < 10; ++i) @@ -74,7 +74,7 @@ TEST (network_filter, many) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); nano::publish message{ nano::dev::network_params.network, block }; auto bytes (message.to_bytes ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 4faa66e0bb..80999549bc 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -183,21 +183,21 @@ TEST (node, send_out_of_order) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (send1->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - 2 * node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .previous (send2->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - 3 * node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); + .build (); node1.process_active (send3); node1.process_active (send2); node1.process_active (send1); @@ -219,7 +219,7 @@ TEST (node, quick_confirm) .balance (node1.online_reps.delta () + 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1.process_active (send); ASSERT_TIMELY (10s, !node1.balance (key.pub).is_zero ()); ASSERT_EQ (node1.balance (nano::dev::genesis_key.pub), node1.online_reps.delta () + 1); @@ -239,7 +239,7 @@ TEST (node, node_receive_quorum) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1.process_active (send); ASSERT_TIMELY (10s, node1.ledger.block_or_pruned_exists (send->hash ())); ASSERT_TIMELY (10s, node1.active.election (nano::qualified_root (previous, previous)) != nullptr); @@ -514,7 +514,7 @@ TEST (node, confirm_locked) .balance (0) .sign (nano::keypair ().prv, 0) .work (0) - .build_shared (); + .build (); system.nodes[0]->network.flood_block (block); } @@ -551,7 +551,7 @@ TEST (node, fork_publish) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); nano::keypair key2; auto send2 = builder.make_block () @@ -560,7 +560,7 @@ TEST (node, fork_publish) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); node1.process_active (send1); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); @@ -602,7 +602,7 @@ TEST (node, fork_publish_inactive) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) @@ -610,7 +610,7 @@ TEST (node, fork_publish_inactive) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (send1->block_work ()) - .build_shared (); + .build (); node.process_active (send1); ASSERT_TIMELY (5s, node.block (send1->hash ())); @@ -649,14 +649,14 @@ TEST (node, fork_keep) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send1); node2.process_active (send1); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); @@ -698,7 +698,7 @@ TEST (node, fork_flip) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () @@ -707,7 +707,7 @@ TEST (node, fork_flip) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::publish publish2{ nano::dev::network_params.network, send2 }; auto ignored_channel{ std::make_shared (node1, std::weak_ptr ()) }; @@ -755,7 +755,7 @@ TEST (node, fork_multi_flip) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::keypair key2; auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) @@ -763,14 +763,14 @@ TEST (node, fork_multi_flip) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .previous (send2->hash ()) .destination (key2.pub) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); // Node2 has two blocks that will be rolled back by node1's vote ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); @@ -811,7 +811,7 @@ TEST (node, fork_bootstrap_flip) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system0.work.generate (latest)) - .build_shared (); + .build (); nano::keypair key2; auto send2 = builder.make_block () .previous (latest) @@ -819,7 +819,7 @@ TEST (node, fork_bootstrap_flip) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system0.work.generate (latest)) - .build_shared (); + .build (); // Insert but don't rebroadcast, simulating settled blocks ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); @@ -851,7 +851,7 @@ TEST (node, fork_open) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 = std::make_shared (node); node.network.inbound (publish1, channel1); @@ -871,7 +871,7 @@ TEST (node, fork_open) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); nano::publish publish2{ nano::dev::network_params.network, open1 }; node.network.inbound (publish2, channel1); ASSERT_TIMELY_EQ (5s, 1, node.active.size ()); @@ -883,7 +883,7 @@ TEST (node, fork_open) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); nano::publish publish3{ nano::dev::network_params.network, open2 }; node.network.inbound (publish3, channel1); ASSERT_TIMELY (5s, (election = node.active.election (publish3.block->qualified_root ())) != nullptr); @@ -918,7 +918,7 @@ TEST (node, fork_open_flip) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send1); // We should be keeping this block @@ -929,7 +929,7 @@ TEST (node, fork_open_flip) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); // create a fork of block open1, this block will lose the election auto open2 = builder.make_block () @@ -938,7 +938,7 @@ TEST (node, fork_open_flip) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_FALSE (*open1 == *open2); // give block open1 to node1, manually trigger an election for open1 and ensure it is in the ledger @@ -1043,7 +1043,7 @@ TEST (node, fork_no_vote_quorum) .balance ((nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block->hash ())) - .build_shared (); + .build (); nano::raw_key key3; auto transaction (system.wallet (1)->wallets.tx_begin_read ()); ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3)); @@ -1100,7 +1100,7 @@ TEST (node, DISABLED_fork_pre_confirm) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); auto block3 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (node0.latest (nano::dev::genesis_key.pub)) @@ -1109,7 +1109,7 @@ TEST (node, DISABLED_fork_pre_confirm) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node0.work_generate_blocking (*block2); node0.work_generate_blocking (*block3); node0.process_active (block2); @@ -1150,7 +1150,7 @@ TEST (node, DISABLED_fork_stale) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send3); node1.process_active (send3); system2.deadline_set (10s); @@ -1167,7 +1167,7 @@ TEST (node, DISABLED_fork_stale) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send1); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -1177,7 +1177,7 @@ TEST (node, DISABLED_fork_stale) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*send2); { auto transaction1 (node1.store.tx_begin_write ()); @@ -1302,7 +1302,7 @@ TEST (node, DISABLED_broadcast_elected) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (node2->latest (nano::dev::genesis_key.pub))) - .build_shared (); + .build (); // A copy is necessary to avoid data races during ledger processing, which sets the sideband auto fork0_copy (std::make_shared (*fork0)); node0->process_active (fork0); @@ -1313,7 +1313,7 @@ TEST (node, DISABLED_broadcast_elected) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (node2->latest (nano::dev::genesis_key.pub))) - .build_shared (); + .build (); system.wallet (2)->insert_adhoc (rep_small.prv); node2->process_active (fork1); ASSERT_TIMELY (10s, node0->ledger.block_or_pruned_exists (fork0->hash ()) && node1->ledger.block_or_pruned_exists (fork0->hash ())); @@ -1368,7 +1368,7 @@ TEST (node, rep_self_vote) .balance (nano::uint128_t ("0x60000000000000000000000000000000")) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (fund_big.hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*block0)); auto & active = node0->active; auto & scheduler = node0->scheduler; @@ -1443,7 +1443,7 @@ TEST (node, DISABLED_bootstrap_bulk_push) .balance (500) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); @@ -1539,7 +1539,7 @@ TEST (node, bootstrap_confirm_frontiers) .balance (nano::dev::constants.genesis_amount - 500) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); // each system only has one node, so there should be no bootstrapping going on @@ -1597,7 +1597,7 @@ TEST (node, unconfirmed_send) .link (nano::dev::genesis->account ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (recv1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node2.process (*send2)); auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio); @@ -2064,7 +2064,7 @@ TEST (node, online_reps_election) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send1); ASSERT_TIMELY_EQ (5s, 1, node1.active.size ()); // Process vote for ongoing election @@ -2092,11 +2092,11 @@ TEST (node, block_confirm) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // A copy is necessary to avoid data races during ledger processing, which sets the sideband auto send1_copy = builder.make_block () .from (*send1) - .build_shared (); + .build (); auto hash1 = send1->hash (); auto hash2 = send1_copy->hash (); node1.block_processor.add (send1); @@ -2126,7 +2126,7 @@ TEST (node, confirm_quorum) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ()); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ())); @@ -2153,7 +2153,7 @@ TEST (node, local_votes_cache) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) @@ -2162,7 +2162,7 @@ TEST (node, local_votes_cache) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) @@ -2171,7 +2171,7 @@ TEST (node, local_votes_cache) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send2->hash ())) - .build_shared (); + .build (); { auto transaction (node.store.tx_begin_write ()); ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send1)); @@ -2242,7 +2242,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); @@ -2254,7 +2254,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) @@ -2264,7 +2264,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; nano::confirm_req message{ nano::dev::network_params.network, batch }; @@ -2327,7 +2327,7 @@ TEST (node, local_votes_cache_generate_new_vote) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send1)); // One of the hashes is cached std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; @@ -2366,7 +2366,7 @@ TEST (node, local_votes_cache_fork) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send1_fork = nano::state_block_builder () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -2375,7 +2375,7 @@ TEST (node, local_votes_cache_fork) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); // Cache vote auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); @@ -2408,14 +2408,14 @@ TEST (node, vote_republish) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // process send1 first, this will make sure send1 goes into the ledger and an election is started node1.process_active (send1); @@ -2466,7 +2466,7 @@ TEST (node, vote_by_hash_bundle) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); blocks.push_back (block); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); for (auto i = 2; i < 200; ++i) @@ -2477,7 +2477,7 @@ TEST (node, vote_by_hash_bundle) .balance (nano::dev::constants.genesis_amount - i) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (blocks.back ()->hash ())) - .build_shared (); + .build (); blocks.push_back (block); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); } @@ -2526,14 +2526,14 @@ TEST (node, vote_by_hash_republish) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // give block send1 to node1 and check that an election for send1 starts on both nodes node1.process_active (send1); @@ -2576,7 +2576,7 @@ TEST (node, DISABLED_vote_by_hash_epoch_block_republish) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto epoch1 = nano::state_block_builder () .account (nano::dev::genesis->account ()) .previous (nano::dev::genesis->hash ()) @@ -2585,7 +2585,7 @@ TEST (node, DISABLED_vote_by_hash_epoch_block_republish) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1.process_active (send1); ASSERT_TIMELY (5s, node2.active.active (*send1)); node1.active.publish (epoch1); @@ -2620,7 +2620,7 @@ TEST (node, epoch_conflict_confirm) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto open = builder.make_block () .account (key.pub) .previous (0) @@ -2629,7 +2629,7 @@ TEST (node, epoch_conflict_confirm) .link (send->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); auto change = builder.make_block () .account (key.pub) .previous (open->hash ()) @@ -2638,7 +2638,7 @@ TEST (node, epoch_conflict_confirm) .link (0) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send->hash ()) @@ -2647,7 +2647,7 @@ TEST (node, epoch_conflict_confirm) .link (open->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) - .build_shared (); + .build (); auto epoch_open = builder.make_block () .account (change->root ().as_account ()) .previous (0) @@ -2656,7 +2656,7 @@ TEST (node, epoch_conflict_confirm) .link (node0.ledger.epoch_link (nano::epoch::epoch_1)) .sign (epoch_signer.prv, epoch_signer.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); // Process initial blocks on node1 ASSERT_TRUE (nano::test::process (node1, { send, send2, open })); @@ -2716,14 +2716,14 @@ TEST (node, DISABLED_fork_invalid_block_signature) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2_corrupt (std::make_shared (*send2)); send2_corrupt->signature = nano::signature (123); auto vote = nano::test::make_vote (nano::dev::genesis_key, { send2 }, 0, 0); @@ -2755,7 +2755,7 @@ TEST (node, fork_election_invalid_block_signature) .link (nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); auto send2 = builder.state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -2764,7 +2764,7 @@ TEST (node, fork_election_invalid_block_signature) .link (nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); auto send3 = builder.state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -2773,7 +2773,7 @@ TEST (node, fork_election_invalid_block_signature) .link (nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .sign (nano::dev::genesis_key.prv, 0) // Invalid signature - .build_shared (); + .build (); auto channel1 = std::make_shared (node1); node1.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1); @@ -2805,7 +2805,7 @@ TEST (node, block_processor_signatures) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (latest)) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) @@ -2814,7 +2814,7 @@ TEST (node, block_processor_signatures) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) @@ -2823,7 +2823,7 @@ TEST (node, block_processor_signatures) .link (key3.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send2->hash ())) - .build_shared (); + .build (); // Invalid signature bit auto send4 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -2833,7 +2833,7 @@ TEST (node, block_processor_signatures) .link (key3.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send3->hash ())) - .build_shared (); + .build (); send4->signature.bytes[32] ^= 0x1; // Invalid signature bit (force) auto send5 = builder.make_block () @@ -2844,7 +2844,7 @@ TEST (node, block_processor_signatures) .link (key3.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send3->hash ())) - .build_shared (); + .build (); send5->signature.bytes[32] ^= 0x1; // Invalid signature to unchecked node1.unchecked.put (send5->previous (), nano::unchecked_info{ send5 }); @@ -2856,7 +2856,7 @@ TEST (node, block_processor_signatures) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node1.work_generate_blocking (key1.pub)) - .build_shared (); + .build (); auto receive2 = builder.make_block () .account (key2.pub) .previous (0) @@ -2865,7 +2865,7 @@ TEST (node, block_processor_signatures) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*node1.work_generate_blocking (key2.pub)) - .build_shared (); + .build (); // Invalid private key auto receive3 = builder.make_block () .account (key3.pub) @@ -2875,7 +2875,7 @@ TEST (node, block_processor_signatures) .link (send3->hash ()) .sign (key2.prv, key3.pub) .work (*node1.work_generate_blocking (key3.pub)) - .build_shared (); + .build (); node1.process_active (send1); node1.process_active (send2); node1.process_active (send3); @@ -2907,7 +2907,7 @@ TEST (node, block_processor_reject_state) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); send1->signature.bytes[0] ^= 1; ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); node.process_active (send1); @@ -2921,7 +2921,7 @@ TEST (node, block_processor_reject_state) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node.process_active (send2); ASSERT_TIMELY (5s, node.ledger.block_or_pruned_exists (send2->hash ())); } @@ -2942,7 +2942,7 @@ TEST (node, block_processor_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -2951,7 +2951,7 @@ TEST (node, block_processor_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -2960,7 +2960,7 @@ TEST (node, block_processor_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node.block_processor.stop (); // Stop processing the block queue node.block_processor.add (send1); ASSERT_FALSE (node.block_processor.full ()); @@ -2987,7 +2987,7 @@ TEST (node, block_processor_half_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) @@ -2996,7 +2996,7 @@ TEST (node, block_processor_half_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); auto send3 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) @@ -3005,7 +3005,7 @@ TEST (node, block_processor_half_full) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send2->hash ())) - .build_shared (); + .build (); // The write guard prevents block processor doing any writes auto write_guard = node.write_database_queue.wait (nano::writer::testing); node.block_processor.add (send1); @@ -3030,7 +3030,7 @@ TEST (node, confirm_back) .balance (genesis_start_balance - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::state_block_builder builder; auto open = builder.make_block () .account (key.pub) @@ -3040,7 +3040,7 @@ TEST (node, confirm_back) .link (send1->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (key.pub) .previous (open->hash ()) @@ -3049,7 +3049,7 @@ TEST (node, confirm_back) .link (nano::dev::genesis_key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); node.process_active (send1); node.process_active (open); node.process_active (send2); @@ -3233,7 +3233,7 @@ TEST (node, bidirectional_tcp) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1->process_active (send1); ASSERT_TIMELY (10s, node1->ledger.block_or_pruned_exists (send1->hash ()) && node2->ledger.block_or_pruned_exists (send1->hash ())); // Test block confirmation from node 1 (add representative to node 1) @@ -3266,7 +3266,7 @@ TEST (node, bidirectional_tcp) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); node2->process_active (send2); ASSERT_TIMELY (10s, node1->ledger.block_or_pruned_exists (send2->hash ()) && node2->ledger.block_or_pruned_exists (send2->hash ())); // Test block confirmation from node 2 (add representative to node 2) @@ -3317,7 +3317,7 @@ TEST (node, rollback_vote_self) .balance (nano::dev::constants.genesis_amount - (nano::dev::constants.genesis_amount / 2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto open = builder.make_block () .account (key.pub) @@ -3327,7 +3327,7 @@ TEST (node, rollback_vote_self) .balance (nano::dev::constants.genesis_amount / 2) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); // send 1 raw auto send2 = builder.make_block () @@ -3337,14 +3337,14 @@ TEST (node, rollback_vote_self) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); // fork of send2 block auto fork = builder.make_block () .from (*send2) .balance (send1->balance ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .build_shared (); + .build (); // Process and mark the first 2 blocks as confirmed to allow voting ASSERT_TRUE (nano::test::process (node, { send1, open })); @@ -3415,7 +3415,7 @@ TEST (node, rollback_gap_source) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Side a of a forked open block receiving from send1 // This is a losing block auto fork1a = builder.make_block () @@ -3426,7 +3426,7 @@ TEST (node, rollback_gap_source) .balance (1) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) @@ -3434,14 +3434,14 @@ TEST (node, rollback_gap_source) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); // Side b of a forked open block receiving from send2. // This is the winning block auto fork1b = builder.make_block () .from (*fork1a) .link (send2->hash ()) .sign (key.prv, key.pub) - .build_shared (); + .build (); // Set 'node' up with losing block 'fork1a' ASSERT_EQ (nano::block_status::progress, node.process (*send1)); ASSERT_EQ (nano::block_status::progress, node.process (*fork1a)); @@ -3486,7 +3486,7 @@ TEST (node, dependency_graph) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Receive from genesis auto key1_open = builder.make_block () .account (key1.pub) @@ -3687,7 +3687,7 @@ TEST (node, dependency_graph_frontier) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); // Receive from genesis auto key1_open = builder.make_block () .account (key1.pub) @@ -3854,7 +3854,7 @@ TEST (node, deferred_dependent_elections) .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto open = builder.make_block () .account (key.pub) .previous (0) @@ -3863,7 +3863,7 @@ TEST (node, deferred_dependent_elections) .balance (1) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) @@ -3871,7 +3871,7 @@ TEST (node, deferred_dependent_elections) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); auto receive = builder.make_block () .from (*open) .previous (open->hash ()) @@ -3879,12 +3879,12 @@ TEST (node, deferred_dependent_elections) .balance (2) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) - .build_shared (); + .build (); auto fork = builder.make_block () .from (*receive) .representative (nano::dev::genesis_key.pub) // was key.pub .sign (key.prv, key.pub) - .build_shared (); + .build (); nano::test::process (node, { send1 }); auto election_send1 = nano::test::start_election (system, node, send1->hash ()); @@ -4019,7 +4019,7 @@ TEST (node, pruning_automatic) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send1); latest_hash = send1->hash (); @@ -4029,7 +4029,7 @@ TEST (node, pruning_automatic) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send2); ASSERT_TIMELY (5s, node1.block (send2->hash ()) != nullptr); @@ -4071,7 +4071,7 @@ TEST (node, pruning_age) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send1); latest_hash = send1->hash (); @@ -4081,7 +4081,7 @@ TEST (node, pruning_age) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send2); // Force-confirm both blocks @@ -4132,7 +4132,7 @@ TEST (node, pruning_depth) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send1); latest_hash = send1->hash (); @@ -4142,7 +4142,7 @@ TEST (node, pruning_depth) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) - .build_shared (); + .build (); node1.process_active (send2); // Force-confirm both blocks diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 93b3edc5b4..2d6f9ddf4f 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -26,7 +26,7 @@ TEST (request_aggregator, one) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -72,7 +72,7 @@ TEST (request_aggregator, one_update) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); @@ -84,7 +84,7 @@ TEST (request_aggregator, one_update) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) @@ -94,7 +94,7 @@ TEST (request_aggregator, one_update) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); @@ -138,7 +138,7 @@ TEST (request_aggregator, two) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); @@ -150,7 +150,7 @@ TEST (request_aggregator, two) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); auto receive1 = builder.make_block () .account (key1.pub) .previous (0) @@ -159,7 +159,7 @@ TEST (request_aggregator, two) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); std::vector> request; @@ -215,7 +215,7 @@ TEST (request_aggregator, two_endpoints) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); @@ -324,7 +324,7 @@ TEST (request_aggregator, channel_lifetime) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -355,7 +355,7 @@ TEST (request_aggregator, channel_update) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -395,7 +395,7 @@ TEST (request_aggregator, channel_max_queue) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -423,7 +423,7 @@ TEST (request_aggregator, unique) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -456,14 +456,14 @@ TEST (request_aggregator, cannot_vote) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) .balance (send1->balance ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.process (*send1)); ASSERT_EQ (nano::block_status::progress, node.process (*send2)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); diff --git a/nano/core_test/scheduler_buckets.cpp b/nano/core_test/scheduler_buckets.cpp index 0a9c6adfba..0b3aff2381 100644 --- a/nano/core_test/scheduler_buckets.cpp +++ b/nano/core_test/scheduler_buckets.cpp @@ -42,7 +42,7 @@ std::shared_ptr & blockzero () .link (0) .sign (keyzero ().prv, keyzero ().pub) .work (0) - .build_shared (); + .build (); return result; } std::shared_ptr & block0 () @@ -57,7 +57,7 @@ std::shared_ptr & block0 () .link (0) .sign (key0 ().prv, key0 ().pub) .work (0) - .build_shared (); + .build (); return result; } std::shared_ptr & block1 () @@ -72,7 +72,7 @@ std::shared_ptr & block1 () .link (0) .sign (key1 ().prv, key1 ().pub) .work (0) - .build_shared (); + .build (); return result; } std::shared_ptr & block2 () @@ -87,7 +87,7 @@ std::shared_ptr & block2 () .link (0) .sign (key2 ().prv, key2 ().pub) .work (0) - .build_shared (); + .build (); return result; } std::shared_ptr & block3 () @@ -102,7 +102,7 @@ std::shared_ptr & block3 () .link (0) .sign (key3 ().prv, key3 ().pub) .work (0) - .build_shared (); + .build (); return result; } diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index e40916700b..1ef8be8d03 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -58,7 +58,7 @@ TEST (system, DISABLED_generate_send_existing) .account (stake_preserver.pub) .sign (stake_preserver.prv, stake_preserver.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); } @@ -109,7 +109,7 @@ TEST (system, DISABLED_generate_send_new) .account (stake_preserver.pub) .sign (stake_preserver.prv, stake_preserver.pub) .work (0) - .build_shared (); + .build (); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); } diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 6b3c799652..3688b6f5e0 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -37,7 +37,7 @@ std::shared_ptr block () .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); } } @@ -65,7 +65,7 @@ TEST (block_store, one_bootstrap) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); unchecked.put (block1->hash (), nano::unchecked_info{ block1 }); auto check_block_is_listed = [&] (nano::block_hash const & block_hash_a) { return unchecked.get (block_hash_a).size () > 0; @@ -98,7 +98,7 @@ TEST (unchecked, simple) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (block->previous ()); ASSERT_TRUE (block_listing1.empty ()); @@ -139,7 +139,7 @@ TEST (unchecked, multiple) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (block->previous ()); ASSERT_TRUE (block_listing1.empty ()); @@ -169,7 +169,7 @@ TEST (unchecked, double_put) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (block->previous ()); ASSERT_TRUE (block_listing1.empty ()); @@ -201,7 +201,7 @@ TEST (unchecked, multiple_get) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); auto block2 = builder .send () .previous (3) @@ -209,7 +209,7 @@ TEST (unchecked, multiple_get) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); auto block3 = builder .send () .previous (5) @@ -217,7 +217,7 @@ TEST (unchecked, multiple_get) .balance (2) .sign (nano::keypair ().prv, 4) .work (5) - .build_shared (); + .build (); // Add the blocks' info to the unchecked table unchecked.put (block1->previous (), nano::unchecked_info (block1)); // unchecked1 unchecked.put (block1->hash (), nano::unchecked_info (block1)); // unchecked2 diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index d43f1d3830..03d322935a 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -158,7 +158,7 @@ TEST (vote_spacing, vote_generator) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -167,7 +167,7 @@ TEST (vote_spacing, vote_generator) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); @@ -202,7 +202,7 @@ TEST (vote_spacing, rapid) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) @@ -211,7 +211,7 @@ TEST (vote_spacing, rapid) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index bc2fa0140b..317d999e74 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -99,7 +99,7 @@ TEST (websocket, confirmation) .balance (balance) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); } @@ -118,7 +118,7 @@ TEST (websocket, confirmation) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); } @@ -158,7 +158,7 @@ TEST (websocket, started_election) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 = std::make_shared (*node1); node1->network.inbound (publish1, channel1); @@ -206,7 +206,7 @@ TEST (websocket, stopped_election) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 = std::make_shared (*node1); node1->network.inbound (publish1, channel1); @@ -264,7 +264,7 @@ TEST (websocket, confirmation_options) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); previous = send->hash (); @@ -297,7 +297,7 @@ TEST (websocket, confirmation_options) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); previous = send->hash (); @@ -360,7 +360,7 @@ TEST (websocket, confirmation_options) .balance (balance) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); previous = send->hash (); } @@ -406,7 +406,7 @@ TEST (websocket, confirmation_options_votes) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); previous = send->hash (); @@ -493,7 +493,7 @@ TEST (websocket, confirmation_options_sideband) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); previous = send->hash (); @@ -574,7 +574,7 @@ TEST (websocket, confirmation_options_update) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); @@ -592,7 +592,7 @@ TEST (websocket, confirmation_options_update) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send2); @@ -634,7 +634,7 @@ TEST (websocket, vote) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); @@ -736,7 +736,7 @@ TEST (websocket, vote_options_representatives) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); node1->process_active (send); }; confirm_block (); @@ -1059,7 +1059,7 @@ TEST (websocket, new_unconfirmed_block) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process_local (send1).value ()); diff --git a/nano/lib/blockbuilders.cpp b/nano/lib/blockbuilders.cpp index edb5499d95..69b375eb11 100644 --- a/nano/lib/blockbuilders.cpp +++ b/nano/lib/blockbuilders.cpp @@ -652,7 +652,7 @@ nano::receive_block_builder & nano::receive_block_builder::source_hex (std::stri } template -std::unique_ptr nano::abstract_builder::build () +std::shared_ptr nano::abstract_builder::build () { if (!ec) { @@ -663,7 +663,7 @@ std::unique_ptr nano::abstract_builder::build () } template -std::unique_ptr nano::abstract_builder::build (std::error_code & ec) +std::shared_ptr nano::abstract_builder::build (std::error_code & ec) { if (!this->ec) { @@ -673,18 +673,6 @@ std::unique_ptr nano::abstract_builder::build (st return std::move (block); } -template -std::shared_ptr nano::abstract_builder::build_shared () -{ - return std::move (build ()); -} - -template -std::shared_ptr nano::abstract_builder::build_shared (std::error_code & ec) -{ - return std::move (build (ec)); -} - template nano::abstract_builder & nano::abstract_builder::work (uint64_t work) { diff --git a/nano/lib/blockbuilders.hpp b/nano/lib/blockbuilders.hpp index d77a441f01..077d584019 100644 --- a/nano/lib/blockbuilders.hpp +++ b/nano/lib/blockbuilders.hpp @@ -44,14 +44,10 @@ template class abstract_builder { public: - /** Returns the built block as a unique_ptr */ - std::unique_ptr build (); - /** Returns the built block as a unique_ptr. Any errors are placed in \p ec */ - std::unique_ptr build (std::error_code & ec); - /** Returns the built block as a shared_ptr */ - std::shared_ptr build_shared (); - /** Returns the built block as a shared_ptr. Any errors are placed in \p ec */ - std::shared_ptr build_shared (std::error_code & ec); + /** Returns the built block*/ + std::shared_ptr build (); + /** Returns the built block. Any errors are placed in \p ec */ + std::shared_ptr build (std::error_code & ec); /** Set work value */ abstract_builder & work (uint64_t work); /** Sign the block using the \p private_key and \p public_key */ diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 3a5bf6dfe8..fd890c37a9 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -1183,7 +1183,7 @@ TEST (rpc, history_pruning) .representative (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); blocks.push_back (change); // legacy send to itself @@ -1194,7 +1194,7 @@ TEST (rpc, history_pruning) .balance (nano::dev::constants.genesis_amount - node0->config.receive_minimum.number ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work.generate (change->hash ())) - .build_shared (); + .build (); blocks.push_back (send); // legacy receive the legacy self send @@ -1204,7 +1204,7 @@ TEST (rpc, history_pruning) .source (send->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work.generate (send->hash ())) - .build_shared (); + .build (); blocks.push_back (receive); // non legacy self send @@ -1217,7 +1217,7 @@ TEST (rpc, history_pruning) .link (nano::dev::genesis->account ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (receive->hash ())) - .build_shared (); + .build (); blocks.push_back (usend); // non legacy receive of the non legacy self send @@ -1230,7 +1230,7 @@ TEST (rpc, history_pruning) .link (usend->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (usend->hash ())) - .build_shared (); + .build (); blocks.push_back (ureceive); // change genesis to a random rep @@ -1243,7 +1243,7 @@ TEST (rpc, history_pruning) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (ureceive->hash ())) - .build_shared (); + .build (); blocks.push_back (uchange); nano::test::process_live (*node0, blocks); @@ -1438,7 +1438,7 @@ TEST (rpc, process_block_async) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); std::string json1; state_send->serialize_json (json1); request.put ("block", json1); @@ -1556,7 +1556,7 @@ TEST (rpc, process_subtype_open) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node2.process (*send)); auto const rpc_ctx = add_rpc (system, node1); @@ -1605,7 +1605,7 @@ TEST (rpc, process_subtype_receive) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node2.process (*send)); auto const rpc_ctx = add_rpc (system, node1); @@ -2227,7 +2227,7 @@ TEST (rpc, block_count_pruning) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) - .build_shared (); + .build (); node1->process_active (send1); auto receive1 = builder .receive () @@ -2235,7 +2235,7 @@ TEST (rpc, block_count_pruning) .source (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); node1->process_active (receive1); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ())); @@ -2995,7 +2995,7 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables) .link (unopened_account.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); @@ -4276,7 +4276,7 @@ TEST (rpc, block_info_pruning) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) - .build_shared (); + .build (); node1->process_active (send1); auto receive1 = builder .receive () @@ -4284,7 +4284,7 @@ TEST (rpc, block_info_pruning) .source (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); node1->process_active (receive1); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ())); @@ -4342,7 +4342,7 @@ TEST (rpc, pruned_exists) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) - .build_shared (); + .build (); node1->process_active (send1); auto receive1 = builder .receive () @@ -4350,7 +4350,7 @@ TEST (rpc, pruned_exists) .source (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) - .build_shared (); + .build (); node1->process_active (receive1); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ())); @@ -4777,7 +4777,7 @@ TEST (rpc, block_create_state_request_work) { // Test work generation for state blocks both with and without previous (in the latter // case, the account will be used for work generation) - std::unique_ptr epoch2; + std::shared_ptr epoch2; { nano::test::system system (1); system.upgrade_genesis_epoch (*system.nodes.front (), nano::epoch::epoch_1); @@ -5340,7 +5340,7 @@ TEST (rpc, block_confirm) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (nano::dev::genesis->hash ())) - .build_shared (); + .build (); { auto transaction (node->store.tx_begin_write ()); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); @@ -5445,7 +5445,7 @@ TEST (rpc, unchecked) .link (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); auto open2 = builder .state () .account (key.pub) @@ -5455,7 +5455,7 @@ TEST (rpc, unchecked) .link (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); node->process_active (open); node->process_active (open2); // Waits for the last block of the queue to get saved in the database @@ -5497,7 +5497,7 @@ TEST (rpc, unchecked_get) .link (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); node->process_active (open); // Waits for the open block to get saved in the database ASSERT_TIMELY_EQ (10s, 1, node->unchecked.count ()); @@ -5536,7 +5536,7 @@ TEST (rpc, unchecked_clear) .link (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); node->process_active (open); boost::property_tree::ptree request{}; // Waits for the open block to get saved in the database @@ -5799,7 +5799,7 @@ TEST (rpc, memory_stats) .link (0) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); std::vector hashes; hashes.push_back (block->hash ()); auto vote = nano::test::make_vote (key, { hashes }, 0, 0); @@ -5877,7 +5877,7 @@ TEST (rpc, block_confirmed) .balance (10) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); node->process_active (send); ASSERT_TRUE (nano::test::start_elections (system, *node, { send }, true)); @@ -6143,7 +6143,7 @@ TEST (rpc, epoch_upgrade) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); // to opened account + .build (); // to opened account ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto send2 = builder .state () @@ -6154,7 +6154,7 @@ TEST (rpc, epoch_upgrade) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); // to unopened account (pending) + .build (); // to unopened account (pending) ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto send3 = builder .state () @@ -6165,7 +6165,7 @@ TEST (rpc, epoch_upgrade) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); // to burn (0) + .build (); // to burn (0) ASSERT_EQ (nano::block_status::progress, node->process (*send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder @@ -6177,7 +6177,7 @@ TEST (rpc, epoch_upgrade) .link (max_account) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) - .build_shared (); // to max account + .build (); // to max account ASSERT_EQ (nano::block_status::progress, node->process (*send4)); auto open = builder .state () @@ -6188,7 +6188,7 @@ TEST (rpc, epoch_upgrade) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->process (*open)); // Check accounts epochs { @@ -6234,7 +6234,7 @@ TEST (rpc, epoch_upgrade) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) - .build_shared (); // to burn (0) + .build (); // to burn (0) ASSERT_EQ (nano::block_status::progress, node->process (*send5)); auto send6 = builder .state () @@ -6245,7 +6245,7 @@ TEST (rpc, epoch_upgrade) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) - .build_shared (); // to key1 (again) + .build (); // to key1 (again) ASSERT_EQ (nano::block_status::progress, node->process (*send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder @@ -6257,7 +6257,7 @@ TEST (rpc, epoch_upgrade) .link (key3.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) - .build_shared (); // to key3 + .build (); // to key3 ASSERT_EQ (nano::block_status::progress, node->process (*send7)); { // Check pending entry @@ -6306,7 +6306,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); // to opened account + .build (); // to opened account ASSERT_EQ (nano::block_status::progress, node->process (*send1)); auto send2 = builder .state () @@ -6317,7 +6317,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); // to unopened account (pending) + .build (); // to unopened account (pending) ASSERT_EQ (nano::block_status::progress, node->process (*send2)); auto send3 = builder .state () @@ -6328,7 +6328,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) - .build_shared (); // to burn (0) + .build (); // to burn (0) ASSERT_EQ (nano::block_status::progress, node->process (*send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder @@ -6340,7 +6340,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (max_account) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) - .build_shared (); // to max account + .build (); // to max account ASSERT_EQ (nano::block_status::progress, node->process (*send4)); auto open = builder .state () @@ -6351,7 +6351,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->process (*open)); // Check accounts epochs { @@ -6398,7 +6398,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) - .build_shared (); // to burn (0) + .build (); // to burn (0) ASSERT_EQ (nano::block_status::progress, node->process (*send5)); auto send6 = builder .state () @@ -6409,7 +6409,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) - .build_shared (); // to key1 (again) + .build (); // to key1 (again) ASSERT_EQ (nano::block_status::progress, node->process (*send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder @@ -6421,7 +6421,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .link (key3.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) - .build_shared (); // to key3 + .build (); // to key3 ASSERT_EQ (nano::block_status::progress, node->process (*send7)); { // Check pending entry @@ -6470,7 +6470,7 @@ TEST (rpc, account_lazy_start) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); auto open = builder .open () @@ -6479,7 +6479,7 @@ TEST (rpc, account_lazy_start) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node1->process (*open)); // Start lazy bootstrap with account @@ -6869,7 +6869,7 @@ TEST (rpc, confirmation_active) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); auto send2 = builder .send () .previous (send1->hash ()) @@ -6877,7 +6877,7 @@ TEST (rpc, confirmation_active) .balance (nano::dev::constants.genesis_amount - 200) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) - .build_shared (); + .build (); node1->process_active (send1); node1->process_active (send2); ASSERT_TRUE (nano::test::start_elections (system, *node1, { send1, send2 })); @@ -6913,7 +6913,7 @@ TEST (rpc, confirmation_info) .balance (nano::dev::constants.genesis_amount - 100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); node1->process_active (send); ASSERT_TIMELY (5s, !node1->active.empty ()); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index ed8ef26976..9bfa3bddc2 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -287,7 +287,7 @@ TEST (node, fork_storm) .account (key.pub) .sign (key.prv, key.pub) .work (0) - .build_shared (); + .build (); node_i->work_generate_blocking (*open); auto open_result (node_i->process (*open)); ASSERT_EQ (nano::block_status::progress, open_result); @@ -507,7 +507,7 @@ TEST (store, unchecked_load) .balance (0) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) - .build_shared (); + .build (); constexpr auto num_unchecked = 1'000'000; for (auto i (0); i < num_unchecked; ++i) { @@ -618,7 +618,7 @@ TEST (node, mass_vote_by_hash) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) - .build_shared (); + .build (); previous = block->hash (); blocks.push_back (block); } @@ -752,7 +752,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); @@ -878,7 +878,7 @@ TEST (confirmation_height, long_chains) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) - .build_shared (); + .build (); // Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height nano::keypair key2; @@ -962,7 +962,7 @@ TEST (confirmation_height, dynamic_algorithm) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis->hash ())) - .build_shared (); + .build (); latest_genesis = send; state_blocks.push_back (send); } @@ -1028,7 +1028,7 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) - .build_shared (); + .build (); latest_genesis = send->hash (); state_blocks.push_back (send); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); @@ -1124,7 +1124,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); @@ -1161,14 +1161,14 @@ TEST (confirmation_height, many_accounts_send_receive_self) .balance (1) .sign (keypair.prv, keypair.pub) .work (*system.work.generate (open_block->hash ())) - .build_shared ()); + .build ()); receive_blocks.emplace_back (builder .receive () .previous (send_blocks.back ()->hash ()) .source (send_blocks.back ()->hash ()) .sign (keypair.prv, keypair.pub) .work (*system.work.generate (send_blocks.back ()->hash ())) - .build_shared ()); + .build ()); } // Now send and receive to self @@ -1271,7 +1271,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .account (key.pub) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) - .build_shared (); + .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); @@ -1307,14 +1307,14 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .balance (1) .sign (keypair.prv, keypair.pub) .work (*system.work.generate (open_block->hash ())) - .build_shared ()); + .build ()); receive_blocks.emplace_back (builder .receive () .previous (send_blocks.back ()->hash ()) .source (send_blocks.back ()->hash ()) .sign (keypair.prv, keypair.pub) .work (*system.work.generate (send_blocks.back ()->hash ())) - .build_shared ()); + .build ()); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ())); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ())); @@ -1523,7 +1523,7 @@ TEST (telemetry, under_load) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) - .build_shared (); + .build (); node->process_active (send); latest_genesis = send->hash (); auto open = builder @@ -1535,7 +1535,7 @@ TEST (telemetry, under_load) .link (send->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); node->process_active (open); auto latest_key = open->hash (); @@ -1553,7 +1553,7 @@ TEST (telemetry, under_load) .link (key1.pub) .sign (keypair.prv, keypair.pub) .work (*system.work.generate (latest_l)) - .build_shared (); + .build (); latest_l = send->hash (); node->process_active (send); } diff --git a/nano/slow_test/vote_cache.cpp b/nano/slow_test/vote_cache.cpp index 05b5b66ed7..3c4a7ccb40 100644 --- a/nano/slow_test/vote_cache.cpp +++ b/nano/slow_test/vote_cache.cpp @@ -26,7 +26,7 @@ nano::keypair setup_rep (nano::test::system & system, nano::node & node, nano::u .balance (balance - amount) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto open = builder .open () @@ -35,7 +35,7 @@ nano::keypair setup_rep (nano::test::system & system, nano::node & node, nano::u .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); EXPECT_TRUE (nano::test::process (node, { send, open })); EXPECT_TRUE (nano::test::start_elections (system, node, { send, open }, true)); @@ -81,7 +81,7 @@ std::vector> setup_blocks (nano::test::system & sys .balance (balance) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto open = builder .open () @@ -90,7 +90,7 @@ std::vector> setup_blocks (nano::test::system & sys .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); latest = send->hash (); diff --git a/nano/test_common/chains.cpp b/nano/test_common/chains.cpp index dc6123792a..e7a745a33f 100644 --- a/nano/test_common/chains.cpp +++ b/nano/test_common/chains.cpp @@ -23,7 +23,7 @@ nano::block_list_t nano::test::setup_chain (nano::test::system & system, nano::n .link (throwaway.pub) .sign (target.prv, target.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); latest = send->hash (); @@ -63,7 +63,7 @@ std::vector> nano::test::setup_chai .link (key.pub) .sign (source.prv, source.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto open = builder .state () @@ -74,7 +74,7 @@ std::vector> nano::test::setup_chai .link (send->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); latest = send->hash (); @@ -120,7 +120,7 @@ nano::block_list_t nano::test::setup_independent_blocks (nano::test::system & sy .link (key.pub) .sign (source.prv, source.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); latest = send->hash (); @@ -133,7 +133,7 @@ nano::block_list_t nano::test::setup_independent_blocks (nano::test::system & sy .link (send->hash ()) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) - .build_shared (); + .build (); EXPECT_TRUE (nano::test::process (node, { send, open })); EXPECT_TIMELY (5s, nano::test::exists (node, { send, open })); // Ensure blocks are in the ledger @@ -162,7 +162,7 @@ std::pair, std::shared_ptr> nano::test .link (dest.pub) .sign (source.prv, source.pub) .work (*system.work.generate (latest)) - .build_shared (); + .build (); auto open = nano::block_builder () .state () @@ -173,7 +173,7 @@ std::pair, std::shared_ptr> nano::test .link (send->hash ()) .sign (dest.prv, dest.pub) .work (*system.work.generate (dest.pub)) - .build_shared (); + .build (); EXPECT_TRUE (nano::test::process (node, { send, open })); EXPECT_TRUE (nano::test::start_elections (system, node, { send, open }, force_confirm)); diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index 235367453e..611206eb7e 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -56,7 +56,7 @@ auto nano::test::context::ledger_send_receive () -> ledger_context .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); blocks.push_back (send); auto receive = builder.state () .make_block () @@ -67,7 +67,7 @@ auto nano::test::context::ledger_send_receive () -> ledger_context .link (send->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) - .build_shared (); + .build (); blocks.push_back (receive); return ledger_context{ std::move (blocks) }; } @@ -84,7 +84,7 @@ auto nano::test::context::ledger_send_receive_legacy () -> ledger_context .balance (nano::dev::constants.genesis_amount - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) - .build_shared (); + .build (); blocks.push_back (send); auto receive = builder.receive () .make_block () @@ -92,7 +92,7 @@ auto nano::test::context::ledger_send_receive_legacy () -> ledger_context .source (send->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) - .build_shared (); + .build (); blocks.push_back (receive); return ledger_context{ std::move (blocks) }; } diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index a3ea7b5176..35d86b4e7d 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -192,7 +192,7 @@ void nano::test::system::ledger_initialization_set (std::vector c .balance (balance) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*work.generate (previous)); - initialization_blocks.emplace_back (builder.build_shared ()); + initialization_blocks.emplace_back (builder.build ()); previous = initialization_blocks.back ()->hash (); builder.make_block (); builder.account (i.pub) @@ -202,7 +202,7 @@ void nano::test::system::ledger_initialization_set (std::vector c .balance (amount) .sign (i.prv, i.pub) .work (*work.generate (i.pub)); - initialization_blocks.emplace_back (builder.build_shared ()); + initialization_blocks.emplace_back (builder.build ()); } } @@ -239,7 +239,7 @@ uint64_t nano::test::system::work_generate_limited (nano::block_hash const & roo /** Initiate an epoch upgrade. Writes the epoch block into the ledger and leaves it to * node background processes (e.g. frontiers confirmation) to cement the block. */ -std::unique_ptr nano::test::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a) +std::shared_ptr nano::test::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a) { auto transaction (ledger_a.store.tx_begin_write ()); auto dev_genesis_key = nano::dev::genesis_key; @@ -268,7 +268,7 @@ std::unique_ptr nano::test::upgrade_epoch (nano::work_pool & return !error ? std::move (epoch) : nullptr; } -std::unique_ptr nano::test::system::upgrade_genesis_epoch (nano::node & node_a, nano::epoch const epoch_a) +std::shared_ptr nano::test::system::upgrade_genesis_epoch (nano::node & node_a, nano::epoch const epoch_a) { return upgrade_epoch (work, node_a.ledger, epoch_a); } diff --git a/nano/test_common/system.hpp b/nano/test_common/system.hpp index 1f6f0fa660..4230742e90 100644 --- a/nano/test_common/system.hpp +++ b/nano/test_common/system.hpp @@ -38,7 +38,7 @@ namespace test void generate_receive (nano::node &); void generate_send_new (nano::node &, std::vector &); void generate_send_existing (nano::node &, std::vector &); - std::unique_ptr upgrade_genesis_epoch (nano::node &, nano::epoch const); + std::shared_ptr upgrade_genesis_epoch (nano::node &, nano::epoch const); std::shared_ptr wallet (size_t); nano::account account (store::transaction const &, size_t); /** Generate work with difficulty between \p min_difficulty_a (inclusive) and \p max_difficulty_a (exclusive) */ @@ -85,7 +85,7 @@ namespace test std::vector> initialization_blocks; }; - std::unique_ptr upgrade_epoch (nano::work_pool &, nano::ledger &, nano::epoch); + std::shared_ptr upgrade_epoch (nano::work_pool &, nano::ledger &, nano::epoch); void cleanup_dev_directories_on_exit (); } } From 9f89fb8490737a9af7ea93506ca45b6cfa9ddc12 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Mon, 19 Feb 2024 20:03:04 +0000 Subject: [PATCH 100/190] Convert ledger::process to accept a shared_ptr so it can store a reference. --- nano/core_test/active_transactions.cpp | 50 +- nano/core_test/block_store.cpp | 22 +- nano/core_test/bootstrap.cpp | 74 +-- nano/core_test/bootstrap_ascending.cpp | 10 +- nano/core_test/confirmation_height.cpp | 182 +++--- nano/core_test/conflicts.cpp | 4 +- nano/core_test/election.cpp | 4 +- nano/core_test/election_scheduler.cpp | 12 +- nano/core_test/frontiers_confirmation.cpp | 6 +- nano/core_test/ledger.cpp | 670 +++++++++++----------- nano/core_test/network.cpp | 4 +- nano/core_test/node.cpp | 302 +++++----- nano/core_test/processor_service.cpp | 6 +- nano/core_test/request_aggregator.cpp | 30 +- nano/core_test/system.cpp | 4 +- nano/core_test/voting.cpp | 8 +- nano/core_test/wallet.cpp | 4 +- nano/core_test/wallets.cpp | 10 +- nano/nano_node/entry.cpp | 4 +- nano/node/blockprocessor.cpp | 4 +- nano/node/node.cpp | 4 +- nano/node/node.hpp | 4 +- nano/qt_test/qt.cpp | 40 +- nano/rpc_test/receivable.cpp | 2 +- nano/rpc_test/rpc.cpp | 144 ++--- nano/secure/ledger.cpp | 6 +- nano/secure/ledger.hpp | 2 +- nano/slow_test/node.cpp | 60 +- nano/test_common/ledger.cpp | 2 +- nano/test_common/system.cpp | 4 +- nano/test_common/testutil.cpp | 2 +- 31 files changed, 841 insertions(+), 839 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index b984e38bfb..c848ffe250 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -149,7 +149,7 @@ TEST (active_transactions, confirm_frontier) node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); } - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); ASSERT_TIMELY (5s, !node2.active.empty ()); // Save election to check request count afterwards @@ -490,10 +490,10 @@ TEST (active_transactions, inactive_votes_cache_election_start) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*open1)); - ASSERT_EQ (nano::block_status::progress, node.process (*open2)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (open1)); + ASSERT_EQ (nano::block_status::progress, node.process (open2)); ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count); ASSERT_TRUE (node.active.empty ()); ASSERT_EQ (1, node.ledger.cache.cemented_count); @@ -1041,7 +1041,10 @@ TEST (active_transactions, confirmation_consistency) } } -TEST (active_transactions, confirm_new) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3629 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3634 +TEST (active_transactions, DISABLED_confirm_new) { nano::test::system system (1); auto & node1 = *system.nodes[0]; @@ -1060,8 +1063,7 @@ TEST (active_transactions, confirm_new) // Let node2 know about the block ASSERT_TIMELY (5s, node2.block (send->hash ())); // Wait confirmation - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2); - ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2); } // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache @@ -1163,11 +1165,11 @@ TEST (active_transactions, activate_account_chain) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*send3)); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send3)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); ASSERT_TIMELY (5s, node.active.election (send->qualified_root ())); @@ -1246,9 +1248,9 @@ TEST (active_transactions, activate_inactive) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); auto election = nano::test::start_election (system, node, send2->hash ()); ASSERT_NE (nullptr, election); @@ -1283,7 +1285,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -1295,7 +1297,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); auto open = builder.make_block () .account (key.pub) @@ -1307,7 +1309,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); ASSERT_TRUE (nano::test::start_elections (system, node, { send, send2, open })); ASSERT_EQ (3, node.active.size ()); @@ -1340,7 +1342,7 @@ TEST (active_transactions, vacancy) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); node.active.vacancy_update = [&updated] () { updated = true; }; - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); ASSERT_EQ (1, node.active.vacancy ()); ASSERT_EQ (0, node.active.size ()); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -1381,7 +1383,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); node.process_confirmed (nano::election_status{ send1 }); ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ())); @@ -1396,7 +1398,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); node.process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ())); @@ -1409,7 +1411,7 @@ TEST (active_transactions, fifo) .sign (key0.prv, key0.pub) .work (*system.work.generate (key0.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node.process (receive1)); auto receive2 = builder.make_block () .previous (0) @@ -1420,7 +1422,7 @@ TEST (active_transactions, fifo) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive2)); + ASSERT_EQ (nano::block_status::progress, node.process (receive2)); // Ensure first transaction becomes active node.scheduler.manual.push (receive1); diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index c56946267d..6f010ee266 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1021,7 +1021,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = builder .receive () .previous (send->hash ()) @@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto change = builder .change () .previous (receive->hash ()) @@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); auto state_send1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1048,7 +1048,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send1)); auto state_send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1059,7 +1059,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send2)); auto state_send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1070,7 +1070,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send3)); auto state_open = builder .state () .account (key1.pub) @@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_open)); auto epoch = builder .state () .account (key1.pub) @@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch)); auto epoch_open = builder .state () @@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch_open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch_open)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open)); auto state_receive = builder .state () @@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height) .sign (key2.prv, key2.pub) .work (*pool.generate (epoch_open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_receive)); auto open = builder .open () .source (state_send3->hash ()) @@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height) .sign (key3.prv, key3.pub) .work (*pool.generate (key3.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto block1 (store.block.get (transaction, nano::dev::genesis->hash ())); ASSERT_EQ (block1->sideband ().height, 1); auto block2 (store.block.get (transaction, send->hash ())); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 485e49a055..bf1045d118 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -69,7 +69,7 @@ TEST (bulk_pull, end_not_owned) open->refresh (); open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); system.nodes[0]->work_generate_blocking (*open); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; @@ -122,7 +122,7 @@ TEST (bulk_pull, ascending_one_hash) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -154,7 +154,7 @@ TEST (bulk_pull, ascending_two_account) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -189,7 +189,7 @@ TEST (bulk_pull, ascending_end) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -249,7 +249,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0->process (send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -257,7 +257,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node0->process (receive1)); auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket::endpoint_type_t::server), node0)); auto req = std::make_unique (nano::dev::network_params.network); @@ -375,8 +375,8 @@ TEST (bootstrap_processor, process_state) node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block2); - ASSERT_EQ (nano::block_status::progress, node0->process (*block1)); - ASSERT_EQ (nano::block_status::progress, node0->process (*block2)); + ASSERT_EQ (nano::block_status::progress, node0->process (block1)); + ASSERT_EQ (nano::block_status::progress, node0->process (block2)); ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); auto node1 = system.make_disconnected_node (std::nullopt, node_flags); @@ -444,7 +444,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -453,7 +453,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*open)); + ASSERT_EQ (nano::block_status::progress, node0->process (open)); auto send2 = builder .send () .previous (open->hash ()) @@ -462,7 +462,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node0->process (send2)); auto receive = builder .receive () .previous (send1->hash ()) @@ -470,7 +470,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node0->process (receive)); auto node1 = system.make_disconnected_node (); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -541,7 +541,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // open key account receiving all balance of genesis auto open = builder @@ -552,7 +552,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // send from key to genesis 100 raw auto send2 = builder @@ -563,7 +563,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive the 100 raw on genesis auto receive = builder @@ -573,7 +573,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; @@ -614,7 +614,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // receive all balance on key auto open = builder @@ -625,7 +625,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // 1st bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -643,7 +643,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive the 100 raw from key on genesis auto receive = builder @@ -653,7 +653,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); { auto transaction (node1->store.tx_begin_write ()); @@ -1130,7 +1130,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1141,7 +1141,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto open = builder .open () .source (send1->hash ()) @@ -1150,7 +1150,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto receive = builder .state () .account (key.pub) @@ -1161,7 +1161,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive })); @@ -1200,7 +1200,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -1209,7 +1209,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto send2 = builder .state () .account (key.pub) @@ -1220,7 +1220,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // Start lazy bootstrap with last block in chain known auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1259,7 +1259,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // send Gxrb_ratio raw from genesis to key2 auto send2 = builder @@ -1272,7 +1272,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive send1 on key1 auto open = builder @@ -1283,7 +1283,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // receive send2 on key2 auto state_open = builder @@ -1296,7 +1296,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*state_open)); + ASSERT_EQ (nano::block_status::progress, node1->process (state_open)); // Start lazy bootstrap with last block in sender chain auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1744,7 +1744,7 @@ TEST (frontier_req, count) .work (0) .build (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto receive1 = builder .make_block () .account (key1.pub) @@ -1756,7 +1756,7 @@ TEST (frontier_req, count) .work (0) .build (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); @@ -1839,7 +1839,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -1851,7 +1851,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*send2); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto receive1 = builder .make_block () .account (key_before_genesis.pub) @@ -1863,7 +1863,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); auto receive2 = builder .make_block () .account (key_after_genesis.pub) @@ -1875,7 +1875,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*receive2); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive2)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive2)); // Request for all accounts (confirmed only) auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index 914c58c6b5..a9ca258454 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -171,7 +171,7 @@ TEST (bootstrap_ascending, account_base) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); } @@ -206,8 +206,8 @@ TEST (bootstrap_ascending, account_inductive) // std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl; // std::cerr << "Send1: " << send1->hash ().to_string () << std::endl; // std::cerr << "Send2: " << send2->hash ().to_string () << std::endl; - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node0.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send2)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (50s, node1.block (send2->hash ()) != nullptr); } @@ -248,8 +248,8 @@ TEST (bootstrap_ascending, trace_base) // std::cerr << "receive1: " << receive1->hash ().to_string () << std::endl; auto & node1 = *system.add_node (); // std::cerr << "--------------- Start ---------------\n"; - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node0.process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (receive1)); ASSERT_EQ (node1.store.pending.begin (node1.store.tx_begin_read (), nano::pending_key{ key.pub, 0 }), node1.store.pending.end ()); // std::cerr << "node0: " << node0.network.endpoint () << std::endl; // std::cerr << "node1: " << node1.network.endpoint () << std::endl; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 8027db461d..906c6bc2d2 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -199,20 +199,20 @@ TEST (confirmation_height, multiple_accounts) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); // Check confirmation heights of all the accounts (except genesis) are uninitialized (0), // as we have any just added them to the ledger and not processed any live transactions yet. @@ -669,20 +669,20 @@ TEST (confirmation_height, send_receive_between_2_accounts) // Unpocketed send { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6)); } add_callback_stats (*node); @@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); } add_callback_stats (*node); @@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *change)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_change)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, change)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_change)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive3)); } add_callback_stats (*node); @@ -1117,7 +1117,7 @@ TEST (confirmation_height, conflict_rollback_cemented) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a)); + ASSERT_EQ (nano::block_status::progress, node1->process (fork1a)); ASSERT_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true)); ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a })); @@ -1269,7 +1269,7 @@ TEST (confirmation_heightDeathTest, modified_chain) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } uint64_t batch_write_size = 2048; @@ -1290,7 +1290,7 @@ TEST (confirmation_heightDeathTest, modified_chain) ASSERT_DEATH_IF_SUPPORTED (bounded_processor.cement_blocks (scoped_write_guard), ""); } - ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), send)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( @@ -1356,8 +1356,8 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); } uint64_t batch_write_size = 2048; @@ -1379,7 +1379,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) } // Reset conditions and test with the bounded processor - ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), open)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( @@ -1434,8 +1434,8 @@ TEST (confirmation_height, pending_observer_callbacks) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); } add_callback_stats (*node); @@ -1482,7 +1482,7 @@ TEST (confirmation_height, callback_confirmed_history) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } auto send1 = builder @@ -1586,9 +1586,9 @@ TEST (confirmation_height, dependent_election) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); } add_callback_stats (*node); @@ -1729,21 +1729,21 @@ TEST (confirmation_height, cemented_gap_below_receive) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } std::vector observer_order; @@ -1889,21 +1889,21 @@ TEST (confirmation_height, cemented_gap_below_no_cache) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } // Force some blocks to be cemented so that the cached confirmed info variable is empty @@ -1959,7 +1959,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto const send2 = builder.make_block () .previous (send1->hash ()) @@ -1968,7 +1968,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto const send3 = builder.make_block () .previous (send2->hash ()) @@ -1977,7 +1977,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); node->process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ())); @@ -2062,8 +2062,8 @@ TEST (confirmation_height, unbounded_block_cache_iteration) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); } nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded); @@ -2159,11 +2159,11 @@ TEST (confirmation_height, pruned_source) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open2)); } uint64_t batch_write_size = 2; std::atomic stopped{ false }; diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index a670b37770..644388bdba 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -27,7 +27,7 @@ TEST (conflicts, start_stop) .work (0) .build (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); ASSERT_EQ (0, node1.active.size ()); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -56,7 +56,7 @@ TEST (conflicts, add_existing) node1.work_generate_blocking (*send1); // add the block to ledger as an unconfirmed block - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); // wait for send1 to be inserted in the ledger ASSERT_TIMELY (5s, node1.block (send1->hash ())); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index cfd4344380..fc193cc659 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -224,7 +224,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); + ASSERT_EQ (nano::block_status::progress, node1.process (open1)); nano::keypair key2; auto const send2 = builder.make_block () @@ -234,7 +234,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4); node_config.peering_port = system.get_available_port (); diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index db78e13681..af028dd996 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -27,7 +27,7 @@ TEST (election_scheduler, activate_one_timely) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); + system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -45,7 +45,7 @@ TEST (election_scheduler, activate_one_flush) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); + system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -87,7 +87,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); node.process_confirmed (nano::election_status{ send }); auto receive = builder.make_block () @@ -99,7 +99,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); node.process_confirmed (nano::election_status{ receive }); // Second, process two eligible transactions @@ -112,7 +112,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); // There is vacancy so it should be inserted node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -128,7 +128,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*block2)); + ASSERT_EQ (nano::block_status::progress, node.process (block2)); // There is no vacancy so it should stay queued node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ()); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 3b5c29f376..76812a6bc7 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -29,7 +29,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::this_thread::sleep_for (std::chrono::seconds (1)); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 983ed8c735..821d1d4994 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -77,7 +77,7 @@ TEST (ledger, process_modifies_sideband) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send1)); ASSERT_EQ (send1->sideband ().timestamp, store.block.get (store.tx_begin_read (), send1->hash ())->sideband ().timestamp); } @@ -105,7 +105,7 @@ TEST (ledger, process_send) ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, info1->head)); ASSERT_EQ (1, info1->block_count); // This was a valid block, it should progress. - auto return1 = ledger.process (transaction, *send); + auto return1 = ledger.process (transaction, send); ASSERT_EQ (nano::dev::genesis_key.pub, send->sideband ().account); ASSERT_EQ (2, send->sideband ().height); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash1)); @@ -134,7 +134,7 @@ TEST (ledger, process_send) .build (); nano::block_hash hash2 (open->hash ()); // This was a valid block, it should progress. - auto return2 = ledger.process (transaction, *open); + auto return2 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); @@ -212,7 +212,7 @@ TEST (ledger, process_receive) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); nano::keypair key3; auto open = builder .open () @@ -223,7 +223,7 @@ TEST (ledger, process_receive) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - auto return1 = ledger.process (transaction, *open); + auto return1 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (key2.pub, open->sideband ().account); @@ -240,7 +240,7 @@ TEST (ledger, process_receive) .work (*pool.generate (hash1)) .build (); nano::block_hash hash3 = send2->hash (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive = builder .receive () .previous (hash2) @@ -250,7 +250,7 @@ TEST (ledger, process_receive) .build (); auto hash4 = receive->hash (); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2)); - auto return2 = ledger.process (transaction, *receive); + auto return2 = ledger.process (transaction, receive); ASSERT_EQ (key2.pub, receive->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 25, receive->sideband ().balance.number ()); ASSERT_EQ (2, receive->sideband ().height); @@ -300,7 +300,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); nano::keypair key3; auto open = builder .open () @@ -311,7 +311,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -345,7 +345,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); nano::keypair key3; auto change2 = builder .change () @@ -354,7 +354,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change2)); nano::keypair key2; auto send1 = builder .send () @@ -364,7 +364,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair key4; auto open = builder .open () @@ -374,7 +374,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto send2 = builder .send () .previous (send1->hash ()) @@ -383,7 +383,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive1 = builder .receive () .previous (open->hash ()) @@ -391,7 +391,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_EQ (1, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 1, ledger.weight (key4.pub)); auto info1 = ledger.account_info (transaction, key2.pub); @@ -435,7 +435,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = builder .receive () .previous (send->hash ()) @@ -443,7 +443,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_FALSE (ledger.rollback (transaction, receive->hash ())); } @@ -467,8 +467,8 @@ TEST (ledger, process_duplicate) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, send)); auto open = builder .open () .source (hash1) @@ -477,8 +477,8 @@ TEST (ledger, process_duplicate) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, open)); } TEST (ledger, representative_genesis) @@ -520,7 +520,7 @@ TEST (ledger, representative_change) .work (*pool.generate (info1->head)) .build (); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, info1->head)); - auto return1 (ledger.process (transaction, *block)); + auto return1 (ledger.process (transaction, block)); ASSERT_EQ (0, ledger.amount (transaction, block->hash ())); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); @@ -561,7 +561,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .send () .previous (info1->head) @@ -570,7 +570,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block2)); } TEST (ledger, receive_fork) @@ -593,7 +593,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .open () .source (block->hash ()) @@ -602,7 +602,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .change () .previous (block2->hash ()) @@ -610,7 +610,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .send () .previous (block->hash ()) @@ -619,7 +619,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); auto block5 = builder .receive () .previous (block2->hash ()) @@ -627,7 +627,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block5)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block5)); } TEST (ledger, open_fork) @@ -650,7 +650,7 @@ TEST (ledger, open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .open () .source (block->hash ()) @@ -659,7 +659,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block->hash ()) @@ -668,7 +668,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block3)); } TEST (ledger, representation_changes) @@ -701,7 +701,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); nano::keypair key3; auto block2 = builder @@ -712,7 +712,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -724,7 +724,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -735,7 +735,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (200, rep_weights.representation_get (key3.pub)); @@ -747,7 +747,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block5)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -761,7 +761,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -776,7 +776,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (key5.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block7)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block7)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -791,7 +791,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block6->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block8)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block8)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -805,7 +805,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (block7->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block9)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block9)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -834,7 +834,7 @@ TEST (ledger, double_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -843,7 +843,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -852,7 +852,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); } TEST (ledger, double_receive) @@ -872,7 +872,7 @@ TEST (ledger, double_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -881,7 +881,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -889,7 +889,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); } TEST (votes, check_signature) @@ -911,7 +911,7 @@ TEST (votes, check_signature) node1.work_generate_blocking (*send1); { auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); } node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -941,7 +941,7 @@ TEST (votes, add_one) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -983,7 +983,7 @@ TEST (votes, add_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1042,7 +1042,7 @@ TEST (votes, add_old) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1100,8 +1100,8 @@ TEST (votes, DISABLED_add_old_different_account) .work (0) .build (); node1.work_generate_blocking (*send2); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, send2 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -1147,7 +1147,7 @@ TEST (votes, add_cooldown) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1190,7 +1190,7 @@ TEST (ledger, successor) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); ASSERT_EQ (*send1, *node1.ledger.successor (transaction, nano::qualified_root (nano::root (0), nano::dev::genesis->hash ()))); ASSERT_EQ (*nano::dev::genesis, *node1.ledger.successor (transaction, nano::dev::genesis->qualified_root ())); ASSERT_EQ (nullptr, node1.ledger.successor (transaction, nano::qualified_root (0))); @@ -1212,9 +1212,9 @@ TEST (ledger, fail_change_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result1); - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::old, result2); } @@ -1234,7 +1234,7 @@ TEST (ledger, fail_change_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::gap_previous, result1); } @@ -1256,7 +1256,7 @@ TEST (ledger, fail_state_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1279,10 +1279,10 @@ TEST (ledger, fail_epoch_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); block->signature.bytes[0] ^= 1; - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); // Fails epoch signature block->signature.bytes[0] ^= 1; - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result2); // Succeeds with epoch signature } @@ -1302,7 +1302,7 @@ TEST (ledger, fail_change_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1322,7 +1322,7 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); nano::keypair key2; auto block2 = builder @@ -1332,7 +1332,7 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::fork, result2); } @@ -1353,9 +1353,9 @@ TEST (ledger, fail_send_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result1); - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::old, result2); } @@ -1376,7 +1376,7 @@ TEST (ledger, fail_send_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::gap_previous, result1); } @@ -1397,7 +1397,7 @@ TEST (ledger, fail_send_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1418,7 +1418,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair key2; auto block2 = builder .send () @@ -1428,7 +1428,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::negative_spend, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::negative_spend, ledger.process (transaction, block2)); } TEST (ledger, fail_send_fork) @@ -1448,7 +1448,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair key2; auto block2 = builder .send () @@ -1458,7 +1458,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block2)); } TEST (ledger, fail_open_old) @@ -1478,7 +1478,7 @@ TEST (ledger, fail_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1487,8 +1487,8 @@ TEST (ledger, fail_open_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, block2)); } TEST (ledger, fail_open_gap_source) @@ -1508,7 +1508,7 @@ TEST (ledger, fail_open_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::gap_source, result2); } @@ -1529,7 +1529,7 @@ TEST (ledger, fail_open_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1539,7 +1539,7 @@ TEST (ledger, fail_open_bad_signature) .work (*pool.generate (key1.pub)) .build (); block2->signature.clear (); - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, block2)); } TEST (ledger, fail_open_fork_previous) @@ -1559,7 +1559,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1568,7 +1568,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1577,7 +1577,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .open () .source (block2->hash ()) @@ -1586,7 +1586,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block4)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1607,7 +1607,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair badkey; auto block2 = builder .open () @@ -1617,7 +1617,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (badkey.prv, badkey.pub) .work (*pool.generate (badkey.pub)) .build (); - ASSERT_NE (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_NE (nano::block_status::progress, ledger.process (transaction, block2)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1638,7 +1638,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1647,7 +1647,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1656,7 +1656,7 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .receive () .previous (block3->hash ()) @@ -1664,8 +1664,8 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, block4)); } TEST (ledger, fail_receive_gap_source) @@ -1685,7 +1685,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1695,7 +1695,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1705,7 +1705,7 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1714,7 +1714,7 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::gap_source, result4); } @@ -1735,7 +1735,7 @@ TEST (ledger, fail_receive_overreceive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .open () @@ -1745,7 +1745,7 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block2); + auto result3 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result3); auto block3 = builder .receive () @@ -1754,7 +1754,7 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result4 = ledger.process (transaction, *block3); + auto result4 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::unreceivable, result4); } @@ -1775,7 +1775,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1785,7 +1785,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1795,7 +1795,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1804,7 +1804,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::bad_signature, result4); } @@ -1825,7 +1825,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1835,7 +1835,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1845,7 +1845,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1854,7 +1854,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::gap_previous, result4); } @@ -1875,7 +1875,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1885,7 +1885,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .receive () @@ -1894,7 +1894,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::gap_previous, result3); } @@ -1915,7 +1915,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1925,7 +1925,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1935,7 +1935,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder @@ -1946,7 +1946,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () @@ -1955,7 +1955,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result5 = ledger.process (transaction, *block5); + auto result5 = ledger.process (transaction, block5); ASSERT_EQ (nano::block_status::fork, result5); } @@ -1976,7 +1976,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1986,7 +1986,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block6 = builder .send () @@ -1996,7 +1996,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result6 = ledger.process (transaction, *block6); + auto result6 = ledger.process (transaction, block6); ASSERT_EQ (nano::block_status::progress, result6); auto block3 = builder .open () @@ -2006,7 +2006,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder @@ -2017,7 +2017,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () @@ -2026,7 +2026,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block4->hash ())) .build (); - auto result5 = ledger.process (transaction, *block5); + auto result5 = ledger.process (transaction, block5); ASSERT_EQ (nano::block_status::progress, result5); auto block7 = builder .receive () @@ -2035,7 +2035,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result7 = ledger.process (transaction, *block7); + auto result7 = ledger.process (transaction, block7); ASSERT_EQ (nano::block_status::fork, result7); } @@ -2069,7 +2069,7 @@ TEST (ledger, latest_root) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (hash1)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_EQ (send->hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub).as_block_hash ()); } @@ -2091,7 +2091,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair key2; auto change = builder @@ -2101,7 +2101,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); nano::keypair key3; auto open = builder .open () @@ -2111,7 +2111,7 @@ TEST (ledger, change_representative_move_representation) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); } @@ -2134,7 +2134,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - auto return1 = ledger.process (transaction, *send1); + auto return1 = ledger.process (transaction, send1); ASSERT_EQ (nano::block_status::progress, return1); auto send2 = builder .send () @@ -2144,7 +2144,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - auto return2 = ledger.process (transaction, *send2); + auto return2 = ledger.process (transaction, send2); ASSERT_EQ (nano::block_status::progress, return2); nano::keypair key2; auto open = builder @@ -2155,7 +2155,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto return4 = ledger.process (transaction, *open); + auto return4 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return4); auto receive = builder .receive () @@ -2164,7 +2164,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (open->hash ())) .build (); - auto return5 = ledger.process (transaction, *receive); + auto return5 = ledger.process (transaction, receive); ASSERT_EQ (nano::block_status::progress, return5); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.pub)); @@ -2177,7 +2177,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - auto return6 = ledger.process (transaction, *change1); + auto return6 = ledger.process (transaction, change1); ASSERT_EQ (nano::block_status::progress, return6); ASSERT_EQ (100, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); @@ -2224,7 +2224,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ASSERT_EQ (2, ledger.cache.block_count); { @@ -2245,7 +2245,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ASSERT_EQ (3, ledger.cache.block_count); ASSERT_EQ (0, ledger.weight (key2.pub)); @@ -2320,12 +2320,12 @@ TEST (ledger, block_destination_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); ASSERT_TRUE (ledger.block_source (transaction, *block1).is_zero ()); @@ -2359,7 +2359,7 @@ TEST (ledger, state_account) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1->hash ())); } @@ -2381,7 +2381,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2404,7 +2404,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2436,7 +2436,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2454,7 +2454,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2487,7 +2487,7 @@ TEST (ledger, state_rep_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_TRUE (store.block.exists (transaction, change1->hash ())); auto change2 = store.block.get (transaction, change1->hash ()); ASSERT_NE (nullptr, change2); @@ -2521,7 +2521,7 @@ TEST (ledger, state_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2540,7 +2540,7 @@ TEST (ledger, state_open) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); ASSERT_TRUE (store.block.exists (transaction, open1->hash ())); auto open2 = store.block.get (transaction, open1->hash ()); @@ -2575,7 +2575,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -2584,7 +2584,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, send2)); } // Make sure old block types can't be inserted after a state block. @@ -2606,7 +2606,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -2614,7 +2614,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); } // Make sure old block types can't be inserted after a state block. @@ -2636,7 +2636,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto change1 = builder .change () @@ -2645,7 +2645,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); } TEST (ledger, state_unreceivable_fail) @@ -2664,7 +2664,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2682,7 +2682,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, receive1)); } TEST (ledger, state_receive_bad_amount_fail) @@ -2701,7 +2701,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2719,7 +2719,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, receive1)); } TEST (ledger, state_no_link_amount_fail) @@ -2740,7 +2740,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto change1 = builder .state () @@ -2752,7 +2752,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, change1)); } TEST (ledger, state_receive_wrong_account_fail) @@ -2773,7 +2773,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2792,7 +2792,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); } TEST (ledger, state_open_state_fork) @@ -2814,7 +2814,7 @@ TEST (ledger, state_open_state_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2825,7 +2825,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -2834,7 +2834,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); ASSERT_EQ (open1->root (), open2->root ()); } @@ -2857,7 +2857,7 @@ TEST (ledger, state_state_open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -2866,7 +2866,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .state () .account (destination.pub) @@ -2877,7 +2877,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); ASSERT_EQ (open1->root (), open2->root ()); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -2901,7 +2901,7 @@ TEST (ledger, state_open_previous_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2912,7 +2912,7 @@ TEST (ledger, state_open_previous_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (1)) .build (); - ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, open1)); } TEST (ledger, state_open_source_fail) @@ -2934,7 +2934,7 @@ TEST (ledger, state_open_source_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2945,7 +2945,7 @@ TEST (ledger, state_open_source_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, open1)); } TEST (ledger, state_send_change) @@ -2967,7 +2967,7 @@ TEST (ledger, state_send_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3000,7 +3000,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3019,7 +3019,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -3053,7 +3053,7 @@ TEST (ledger, state_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -3062,7 +3062,7 @@ TEST (ledger, state_open_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3087,7 +3087,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3098,7 +3098,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto open1 = builder .open () .source (send1->hash ()) @@ -3107,7 +3107,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -3115,7 +3115,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3139,7 +3139,7 @@ TEST (ledger, state_rollback_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3177,7 +3177,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3188,7 +3188,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); @@ -3220,7 +3220,7 @@ TEST (ledger, state_rollback_received_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .state () .account (key.pub) @@ -3231,7 +3231,7 @@ TEST (ledger, state_rollback_received_send) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); @@ -3263,7 +3263,7 @@ TEST (ledger, state_rep_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); ASSERT_FALSE (store.block.exists (transaction, change1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3290,7 +3290,7 @@ TEST (ledger, state_open_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -3301,7 +3301,7 @@ TEST (ledger, state_open_rollback) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); ASSERT_FALSE (store.block.exists (transaction, open1->hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); @@ -3332,7 +3332,7 @@ TEST (ledger, state_send_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3359,7 +3359,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto receive1 = builder .state () @@ -3371,7 +3371,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3399,7 +3399,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_FALSE (epoch1->sideband ().details.is_send); ASSERT_FALSE (epoch1->sideband ().details.is_receive); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); @@ -3415,7 +3415,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch2)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3423,7 +3423,7 @@ TEST (ledger, epoch_blocks_v1_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3439,7 +3439,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3450,7 +3450,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (send1->sideband ().details.is_send); ASSERT_FALSE (send1->sideband ().details.is_receive); ASSERT_FALSE (send1->sideband ().details.is_epoch); @@ -3464,7 +3464,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open1)); auto epoch3 = builder .state () .account (destination.pub) @@ -3475,7 +3475,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, epoch3)); auto epoch4 = builder .state () .account (destination.pub) @@ -3486,7 +3486,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_FALSE (epoch4->sideband ().details.is_send); ASSERT_FALSE (epoch4->sideband ().details.is_receive); ASSERT_TRUE (epoch4->sideband ().details.is_epoch); @@ -3499,7 +3499,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3510,7 +3510,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch4->hash ())); @@ -3543,7 +3543,7 @@ TEST (ledger, epoch_blocks_v2_general) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); // Trying to upgrade from epoch 0 to epoch 2. It is a requirement epoch upgrades are sequential unless the account is unopened - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch1)); // Set it to the first epoch and it should now succeed epoch1 = builder .state () @@ -3555,7 +3555,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (epoch1->work) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks auto epoch2 = builder @@ -3568,7 +3568,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch2)); ASSERT_EQ (nano::epoch::epoch_2, epoch2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch2->sideband ().source_epoch); // Not used for epoch blocks auto epoch3 = builder @@ -3581,7 +3581,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch3)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_2); @@ -3589,7 +3589,7 @@ TEST (ledger, epoch_blocks_v2_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3600,7 +3600,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3611,7 +3611,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_EQ (nano::epoch::epoch_1, send1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1->sideband ().source_epoch); // Not used for send blocks auto open1 = builder @@ -3622,7 +3622,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open1)); auto epoch4 = builder .state () .account (destination.pub) @@ -3633,7 +3633,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_EQ (nano::epoch::epoch_1, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks auto epoch5 = builder @@ -3646,7 +3646,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch5)); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, epoch5)); auto epoch6 = builder .state () .account (destination.pub) @@ -3657,7 +3657,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch6)); ASSERT_EQ (nano::epoch::epoch_2, epoch6->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch6->sideband ().source_epoch); // Not used for epoch blocks auto receive1 = builder @@ -3667,7 +3667,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3678,7 +3678,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch6->hash ())); @@ -3707,7 +3707,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3718,7 +3718,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3729,7 +3729,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_EQ (nano::epoch::epoch_1, send2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send2->sideband ().source_epoch); // Not used for send blocks auto open1 = builder @@ -3740,7 +3740,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().source_epoch); auto receive1 = builder @@ -3750,7 +3750,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3761,7 +3761,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); auto destination_info = ledger.account_info (transaction, destination.pub); @@ -3776,7 +3776,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::dev::genesis_key.pub, pending_send2->source); ASSERT_EQ (nano::Gxrb_ratio, pending_send2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, pending_send2->epoch); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3793,7 +3793,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (receive2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); auto open2 = builder .open () .source (send3->hash ()) @@ -3802,7 +3802,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination2.prv, destination2.pub) .work (*pool.generate (destination2.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open2)); // Upgrade to epoch 2 and send to destination. Try to create an open block from an epoch 2 source block. nano::keypair destination3; auto epoch2 = builder @@ -3815,7 +3815,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch2)); auto send4 = builder .state () .account (nano::dev::genesis->account ()) @@ -3826,7 +3826,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send4)); auto open3 = builder .open () .source (send4->hash ()) @@ -3835,7 +3835,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination3.prv, destination3.pub) .work (*pool.generate (destination3.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open3)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open3)); // Send it to an epoch 1 account auto send5 = builder .state () @@ -3847,7 +3847,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send5)); destination_info = ledger.account_info (transaction, destination.pub); ASSERT_TRUE (destination_info); ASSERT_EQ (destination_info->epoch (), nano::epoch::epoch_1); @@ -3861,7 +3861,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive3)); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3879,7 +3879,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send6)); auto epoch4 = builder .state () .account (destination4.pub) @@ -3890,7 +3890,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination4.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_EQ (nano::epoch::epoch_2, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); @@ -3913,7 +3913,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3924,7 +3924,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch1)); auto epoch2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3935,7 +3935,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch2)); auto epoch3 = builder .state () .account (nano::dev::genesis->account ()) @@ -3946,7 +3946,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch3)); ASSERT_EQ (nano::epoch::epoch_1, epoch3->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch3->sideband ().source_epoch); // Not used for epoch state blocks auto epoch4 = builder @@ -3959,7 +3959,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch2)); } TEST (ledger, successor_epoch) @@ -4017,11 +4017,11 @@ TEST (ledger, successor_epoch) .work (*pool.generate (open->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *change)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *epoch_open)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, change)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, epoch_open)); ASSERT_EQ (*change, *node1.ledger.successor (transaction, change->qualified_root ())); ASSERT_EQ (*epoch_open, *node1.ledger.successor (transaction, epoch_open->qualified_root ())); ASSERT_EQ (nano::epoch::epoch_1, epoch_open->sideband ().details.epoch); @@ -4044,7 +4044,7 @@ TEST (ledger, epoch_open_pending) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key1.pub)) .build (); - auto process_result = node1.ledger.process (node1.store.tx_begin_write (), *epoch_open); + auto process_result = node1.ledger.process (node1.store.tx_begin_write (), epoch_open); ASSERT_EQ (nano::block_status::gap_epoch_open_pending, process_result); node1.block_processor.add (epoch_open); // Waits for the block to get saved in the database @@ -4135,10 +4135,10 @@ TEST (ledger, block_hash_account_conflict) node1.work_generate_blocking (*receive1); node1.work_generate_blocking (*send2); node1.work_generate_blocking (*open_epoch1); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*receive1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node1.process (*open_epoch1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (receive1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (open_epoch1)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, receive1, send2, open_epoch1 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -4212,7 +4212,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *send1)); ASSERT_FALSE (ledger.could_fit (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); @@ -4238,12 +4238,12 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *open1)); ASSERT_FALSE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); ASSERT_TRUE (ledger.could_fit (transaction, *send2)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); // Create another send to receive @@ -4277,7 +4277,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *receive1)); ASSERT_FALSE (ledger.could_fit (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); // Test epoch (state) @@ -4292,11 +4292,11 @@ TEST (ledger, could_fit) .work (*pool.generate (receive1->hash ())) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); } @@ -4588,7 +4588,7 @@ TEST (ledger, confirmation_height_not_updated) ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); @@ -4600,7 +4600,7 @@ TEST (ledger, confirmation_height_not_updated) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_TRUE (store.confirmation_height.get (transaction, key.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); @@ -4621,7 +4621,7 @@ TEST (ledger, zero_rep) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, block1)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); auto block2 = builder.state () @@ -4633,7 +4633,7 @@ TEST (ledger, zero_rep) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, block2)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0)); } @@ -4649,74 +4649,74 @@ TEST (ledger, work_validation) nano::keypair key; // With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result - auto process_block = [&store, &ledger, &pool] (nano::block & block_a, nano::block_details const details_a) { - auto threshold = nano::dev::network_params.work.threshold (block_a.work_version (), details_a); + auto process_block = [&store, &ledger, &pool] (std::shared_ptr block_a, nano::block_details const details_a) { + auto threshold = nano::dev::network_params.work.threshold (block_a->work_version (), details_a); // Rarely failed with random work, so modify until it doesn't have enough difficulty - while (nano::dev::network_params.work.difficulty (block_a) >= threshold) + while (nano::dev::network_params.work.difficulty (*block_a) >= threshold) { - block_a.block_work_set (block_a.block_work () + 1); + block_a->block_work_set (block_a->block_work () + 1); } EXPECT_EQ (nano::block_status::insufficient_work, ledger.process (store.tx_begin_write (), block_a)); - block_a.block_work_set (*pool.generate (block_a.root (), threshold)); + block_a->block_work_set (*pool.generate (block_a->root (), threshold)); EXPECT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), block_a)); }; std::error_code ec; - auto send = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (gen.pub) - .balance (nano::dev::constants.genesis_amount - 1) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); - ASSERT_FALSE (ec); - - auto receive = *builder.receive () - .previous (send.hash ()) - .source (send.hash ()) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); + auto send = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (gen.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (gen.prv, gen.pub) + .work (0) + .build (ec); ASSERT_FALSE (ec); - auto change = *builder.change () - .previous (receive.hash ()) - .representative (key.pub) + auto receive = builder.receive () + .previous (send->hash ()) + .source (send->hash ()) .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto state = *builder.state () - .account (gen.pub) - .previous (change.hash ()) - .representative (gen.pub) - .balance (nano::dev::constants.genesis_amount - 1) - .link (key.pub) + auto change = builder.change () + .previous (receive->hash ()) + .representative (key.pub) .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto open = *builder.open () - .account (key.pub) - .source (state.hash ()) - .representative (key.pub) - .sign (key.prv, key.pub) + auto state = builder.state () + .account (gen.pub) + .previous (change->hash ()) + .representative (gen.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (key.pub) + .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto epoch = *builder.state () - .account (key.pub) - .previous (open.hash ()) - .balance (1) - .representative (key.pub) - .link (ledger.epoch_link (nano::epoch::epoch_1)) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); + auto open = builder.open () + .account (key.pub) + .source (state->hash ()) + .representative (key.pub) + .sign (key.prv, key.pub) + .work (0) + .build (ec); + ASSERT_FALSE (ec); + + auto epoch = builder.state () + .account (key.pub) + .previous (open->hash ()) + .balance (1) + .representative (key.pub) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (gen.prv, gen.pub) + .work (0) + .build (ec); ASSERT_FALSE (ec); process_block (send, {}); @@ -4746,7 +4746,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) @@ -4757,7 +4757,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2)); auto receive1 = builder.state () .account (key1.pub) @@ -4768,7 +4768,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4784,7 +4784,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (receive1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); ASSERT_TRUE (ledger.store.confirmation_height.get (transaction, key1.pub, height)); height.height += 1; @@ -4818,7 +4818,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) .previous (send1->hash ()) @@ -4828,7 +4828,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height = 3; @@ -4868,7 +4868,7 @@ TEST (ledger, block_confirmed) .build (); // Must be safe against non-existing blocks ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4927,7 +4927,7 @@ TEST (ledger, cache) .build (); { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ++block_count; @@ -4937,7 +4937,7 @@ TEST (ledger, cache) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); } ++block_count; @@ -5008,7 +5008,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send1_stored (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send1_stored); @@ -5024,7 +5024,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5050,7 +5050,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); auto receive1_stored (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive1_stored); @@ -5096,7 +5096,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (last_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_TRUE (store->block.exists (transaction, send->hash ())); auto receive = builder .state () @@ -5108,7 +5108,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_TRUE (store->block.exists (transaction, receive->hash ())); last_hash = receive->hash (); } @@ -5147,7 +5147,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -5158,7 +5158,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto send2 = builder .state () @@ -5170,7 +5170,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5195,7 +5195,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5207,7 +5207,7 @@ TEST (ledger, pruning_source_rollback) ASSERT_EQ (nano::Gxrb_ratio, info2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2->epoch); // Process receive block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5233,7 +5233,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); nano::keypair key1; auto send2 = builder @@ -5244,7 +5244,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); auto send3 = builder @@ -5255,7 +5255,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); ASSERT_TRUE (store->block.exists (transaction, send3->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3->hash ()))); // Pruning action @@ -5283,7 +5283,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5295,7 +5295,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info3->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3->epoch); // Process receive block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); @@ -5308,7 +5308,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5320,7 +5320,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info4->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4->epoch); // Process open block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5348,7 +5348,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_EQ (0, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); // Pruning action for latest block (not valid action) @@ -5356,7 +5356,7 @@ TEST (ledger, pruning_process_error) ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); ASSERT_TRUE (store->pruned.exists (transaction, send1->hash ())); // Attempt to process pruned block again - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, send1)); // Attept to process new block after pruned auto send2 = builder .state () @@ -5368,7 +5368,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, send2)); ASSERT_EQ (1, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); } @@ -5394,7 +5394,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto receive1 = builder .receive () @@ -5403,7 +5403,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); auto change1 = builder .change () .previous (receive1->hash ()) @@ -5411,7 +5411,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); auto send2 = builder .send () .previous (change1->hash ()) @@ -5420,7 +5420,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto open1 = builder .open () .source (send2->hash ()) @@ -5429,7 +5429,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto send3 = builder .send () .previous (open1->hash ()) @@ -5438,7 +5438,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); // Pruning action ASSERT_EQ (3, ledger.pruning_action (transaction, change1->hash (), 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, open1->hash (), 1)); @@ -5481,7 +5481,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5493,7 +5493,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5542,7 +5542,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5554,7 +5554,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5680,7 +5680,7 @@ TEST (ledger, unconfirmed_frontiers) .work (*pool.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send)); unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index e3253fa32a..e6a514b9ad 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -366,7 +366,7 @@ TEST (receivable_processor, confirm_insufficient_pos) .work (0) .build (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node1.process (block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; auto vote = nano::test::make_vote (key1, { block1 }, 0, 0); @@ -389,7 +389,7 @@ TEST (receivable_processor, confirm_sufficient_pos) .work (0) .build (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node1.process (block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 80999549bc..6da8ffee9a 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -771,10 +771,10 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); // Node2 has two blocks that will be rolled back by node1's vote - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send2)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send3)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1 auto election = nano::test::start_election (system, node2, send2->hash ()); @@ -821,8 +821,8 @@ TEST (node, fork_bootstrap_flip) .work (*system0.work.generate (latest)) .build (); // Insert but don't rebroadcast, simulating settled blocks - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send2)); ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block auto again (true); @@ -1033,9 +1033,9 @@ TEST (node, fork_no_vote_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node3.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node2.process (send1)); + ASSERT_EQ (nano::block_status::progress, node3.process (send1)); auto key2 (system.wallet (2)->deterministic_insert ()); auto send2 = nano::send_block_builder () .previous (block->hash ()) @@ -1181,9 +1181,9 @@ TEST (node, DISABLED_fork_stale) node1.work_generate_blocking (*send2); { auto transaction1 (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, send1)); auto transaction2 (node2.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, *send2)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, send2)); } node1.process_active (send1); node1.process_active (send2); @@ -1220,48 +1220,48 @@ TEST (node, DISABLED_broadcast_elected) auto transaction0 (node0->store.tx_begin_write ()); auto transaction1 (node1->store.tx_begin_write ()); auto transaction2 (node2->store.tx_begin_write ()); - auto fund_big = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (rep_big.pub) - .balance (nano::Gxrb_ratio * 5) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open_big = *builder.open () - .source (fund_big.hash ()) - .representative (rep_big.pub) - .account (rep_big.pub) - .sign (rep_big.prv, rep_big.pub) - .work (*system.work.generate (rep_big.pub)) - .build (); - auto fund_small = *builder.send () - .previous (fund_big.hash ()) - .destination (rep_small.pub) - .balance (nano::Gxrb_ratio * 2) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_big.hash ())) - .build (); - auto open_small = *builder.open () - .source (fund_small.hash ()) - .representative (rep_small.pub) - .account (rep_small.pub) - .sign (rep_small.prv, rep_small.pub) - .work (*system.work.generate (rep_small.pub)) - .build (); - auto fund_other = *builder.send () - .previous (fund_small.hash ()) - .destination (rep_other.pub) - .balance (nano::Gxrb_ratio) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_small.hash ())) - .build (); - auto open_other = *builder.open () - .source (fund_other.hash ()) - .representative (rep_other.pub) - .account (rep_other.pub) - .sign (rep_other.prv, rep_other.pub) - .work (*system.work.generate (rep_other.pub)) - .build (); + auto fund_big = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (rep_big.pub) + .balance (nano::Gxrb_ratio * 5) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open_big = builder.open () + .source (fund_big->hash ()) + .representative (rep_big.pub) + .account (rep_big.pub) + .sign (rep_big.prv, rep_big.pub) + .work (*system.work.generate (rep_big.pub)) + .build (); + auto fund_small = builder.send () + .previous (fund_big->hash ()) + .destination (rep_small.pub) + .balance (nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (fund_big->hash ())) + .build (); + auto open_small = builder.open () + .source (fund_small->hash ()) + .representative (rep_small.pub) + .account (rep_small.pub) + .sign (rep_small.prv, rep_small.pub) + .work (*system.work.generate (rep_small.pub)) + .build (); + auto fund_other = builder.send () + .previous (fund_small->hash ()) + .destination (rep_other.pub) + .balance (nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (fund_small->hash ())) + .build (); + auto open_other = builder.open () + .source (fund_other->hash ()) + .representative (rep_other.pub) + .account (rep_other.pub) + .sign (rep_other.prv, rep_other.pub) + .work (*system.work.generate (rep_other.pub)) + .build (); ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_big)); ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_big)); ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_big)); @@ -1337,39 +1337,39 @@ TEST (node, rep_self_vote) auto node0 = system.add_node (node_config); nano::keypair rep_big; nano::block_builder builder; - auto fund_big = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (rep_big.pub) - .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open_big = *builder.open () - .source (fund_big.hash ()) - .representative (rep_big.pub) - .account (rep_big.pub) - .sign (rep_big.prv, rep_big.pub) - .work (*system.work.generate (rep_big.pub)) - .build (); + auto fund_big = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (rep_big.pub) + .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open_big = builder.open () + .source (fund_big->hash ()) + .representative (rep_big.pub) + .account (rep_big.pub) + .sign (rep_big.prv, rep_big.pub) + .work (*system.work.generate (rep_big.pub)) + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (fund_big)); ASSERT_EQ (nano::block_status::progress, node0->process (open_big)); // Confirm both blocks, allowing voting on the upcoming block - node0->start_election (node0->block (open_big.hash ())); + node0->start_election (node0->block (open_big->hash ())); std::shared_ptr election; - ASSERT_TIMELY (5s, election = node0->active.election (open_big.qualified_root ())); + ASSERT_TIMELY (5s, election = node0->active.election (open_big->qualified_root ())); election->force_confirm (); system.wallet (0)->insert_adhoc (rep_big.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2); auto block0 = builder.send () - .previous (fund_big.hash ()) + .previous (fund_big->hash ()) .destination (rep_big.pub) .balance (nano::uint128_t ("0x60000000000000000000000000000000")) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_big.hash ())) + .work (*system.work.generate (fund_big->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*block0)); + ASSERT_EQ (nano::block_status::progress, node0->process (block0)); auto & active = node0->active; auto & scheduler = node0->scheduler; scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ()); @@ -1403,7 +1403,7 @@ TEST (node, DISABLED_bootstrap_no_publish) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *send0)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, send0)); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -1444,7 +1444,7 @@ TEST (node, DISABLED_bootstrap_bulk_push) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); + ASSERT_EQ (nano::block_status::progress, node0->process (send0)); ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); @@ -1475,27 +1475,27 @@ TEST (node, bootstrap_fork_open) auto node1 = system.add_node (node_config); nano::keypair key0; nano::block_builder builder; - auto send0 = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (key0.pub) - .balance (nano::dev::constants.genesis_amount - 500) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open0 = *builder.open () - .source (send0.hash ()) - .representative (1) - .account (key0.pub) - .sign (key0.prv, key0.pub) - .work (*system.work.generate (key0.pub)) - .build (); - auto open1 = *builder.open () - .source (send0.hash ()) - .representative (2) - .account (key0.pub) - .sign (key0.prv, key0.pub) - .work (*system.work.generate (key0.pub)) - .build (); + auto send0 = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (key0.pub) + .balance (nano::dev::constants.genesis_amount - 500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open0 = builder.open () + .source (send0->hash ()) + .representative (1) + .account (key0.pub) + .sign (key0.prv, key0.pub) + .work (*system.work.generate (key0.pub)) + .build (); + auto open1 = builder.open () + .source (send0->hash ()) + .representative (2) + .account (key0.pub) + .sign (key0.prv, key0.pub) + .work (*system.work.generate (key0.pub)) + .build (); // Both know about send0 ASSERT_EQ (nano::block_status::progress, node0->process (send0)); ASSERT_EQ (nano::block_status::progress, node1->process (send0)); @@ -1503,22 +1503,22 @@ TEST (node, bootstrap_fork_open) for (auto node : system.nodes) { node->start_election (node->block (node->latest (nano::dev::genesis_key.pub))); - ASSERT_TIMELY (1s, node->active.election (send0.qualified_root ())); - auto election = node->active.election (send0.qualified_root ()); + ASSERT_TIMELY (1s, node->active.election (send0->qualified_root ())); + auto election = node->active.election (send0->qualified_root ()); ASSERT_NE (nullptr, election); election->force_confirm (); ASSERT_TIMELY (2s, node->active.empty ()); } - ASSERT_TIMELY (3s, node0->block_confirmed (send0.hash ())); + ASSERT_TIMELY (3s, node0->block_confirmed (send0->hash ())); // They disagree about open0/open1 ASSERT_EQ (nano::block_status::progress, node0->process (open0)); ASSERT_EQ (nano::block_status::progress, node1->process (open1)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0.hash ())); + ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0->hash ())); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_TIMELY (1s, node1->active.empty ()); - ASSERT_TIMELY (10s, !node1->ledger.block_or_pruned_exists (open1.hash ()) && node1->ledger.block_or_pruned_exists (open0.hash ())); + ASSERT_TIMELY (10s, !node1->ledger.block_or_pruned_exists (open1->hash ()) && node1->ledger.block_or_pruned_exists (open0->hash ())); } // Unconfirmed blocks from bootstrap should be confirmed @@ -1540,7 +1540,7 @@ TEST (node, bootstrap_confirm_frontiers) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); + ASSERT_EQ (nano::block_status::progress, node0->process (send0)); // each system only has one node, so there should be no bootstrapping going on ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); @@ -1598,7 +1598,7 @@ TEST (node, unconfirmed_send) .sign (key2.prv, key2.pub) .work (*system.work.generate (recv1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node2.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node2.process (send2)); auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio); ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ())); @@ -1698,10 +1698,10 @@ TEST (node, rep_weight) .build (); { auto transaction = node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block3)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4)); } ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); @@ -1788,10 +1788,10 @@ TEST (node, rep_remove) .build (); { auto transaction = searching_node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep2)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep2)); } // Create channel for Rep1 @@ -2127,7 +2127,7 @@ TEST (node, confirm_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ()); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ())); auto election = node1.active.election (send1->qualified_root ()); @@ -2174,8 +2174,8 @@ TEST (node, local_votes_cache) .build (); { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send2)); } // Confirm blocks to allow voting node.start_election (send2); @@ -2205,7 +2205,7 @@ TEST (node, local_votes_cache) // Max cache { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send3)); } nano::confirm_req message3{ nano::dev::network_params.network, send3->hash (), send3->root () }; for (auto i (0); i < 100; ++i) @@ -2243,7 +2243,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -2255,7 +2255,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -2265,7 +2265,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; nano::confirm_req message{ nano::dev::network_params.network, batch }; auto channel = std::make_shared (node); @@ -2328,7 +2328,7 @@ TEST (node, local_votes_cache_generate_new_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); // One of the hashes is cached std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes }; @@ -2376,7 +2376,7 @@ TEST (node, local_votes_cache_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); // Cache vote auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -2468,7 +2468,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); blocks.push_back (block); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), blocks.back ())); for (auto i = 2; i < 200; ++i) { auto block = builder.make_block () @@ -2479,7 +2479,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (blocks.back ()->hash ())) .build (); blocks.push_back (block); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), blocks.back ())); } // Confirming last block will confirm whole chain and allow us to generate votes for those blocks later @@ -3443,8 +3443,8 @@ TEST (node, rollback_gap_source) .sign (key.prv, key.pub) .build (); // Set 'node' up with losing block 'fork1a' - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*fork1a)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (fork1a)); // Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block ASSERT_EQ (nullptr, node.block (send2->hash ())); node.block_processor.force (fork1b); @@ -3457,7 +3457,7 @@ TEST (node, rollback_gap_source) node.process_active (fork1a); ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr); // With send2 block in ledger election can start again to remove fork block - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); node.block_processor.force (fork1b); // Wait for new rollback ASSERT_TIMELY_EQ (5s, node.stats.count (nano::stat::type::rollback, nano::stat::detail::open), 2); @@ -3601,19 +3601,19 @@ TEST (node, dependency_graph) .work (*system.work.generate (key3_receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_epoch)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_epoch)); ASSERT_TRUE (node.active.empty ()); // Hash -> Ancestors @@ -3805,19 +3805,19 @@ TEST (node, dependency_graph_frontier) for (auto const & node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_epoch)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_epoch)); } // node1 can vote, but only on the first block @@ -3931,7 +3931,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NE (nullptr, election_open); // Confirm one of the dependents of the receive but not the other, to ensure both have to be confirmed to start an election on processing - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); ASSERT_FALSE (node.active.active (receive->qualified_root ())); election_open->force_confirm (); ASSERT_TIMELY (5s, node.block_confirmed (open->hash ())); @@ -3944,7 +3944,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); // Processing a fork will also not start an election - ASSERT_EQ (nano::block_status::fork, node.process (*fork)); + ASSERT_EQ (nano::block_status::fork, node.process (fork)); node.process_local (fork); ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index d4fc701452..9a9f33b10d 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -32,7 +32,7 @@ TEST (processor_service, bad_send_signature) .work (*pool.generate (info1->head)) .build (); send->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, send)); } TEST (processor_service, bad_receive_signature) @@ -57,7 +57,7 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info2); auto receive = builder @@ -68,5 +68,5 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (hash1)) .build (); receive->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, receive)); } diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 2d6f9ddf4f..dff3215527 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -36,7 +36,7 @@ TEST (request_aggregator, one) ASSERT_TIMELY (3s, node.aggregator.empty ()); // Not yet in the ledger ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); // In the ledger but no vote generated yet @@ -73,7 +73,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -85,7 +85,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -95,7 +95,7 @@ TEST (request_aggregator, one_update) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); auto client = std::make_shared (node); @@ -139,7 +139,7 @@ TEST (request_aggregator, two) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = builder.make_block () @@ -160,8 +160,8 @@ TEST (request_aggregator, two) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (receive1->hash (), receive1->root ()); @@ -218,7 +218,7 @@ TEST (request_aggregator, two_endpoints) .build (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); auto dummy_channel1 = std::make_shared (node1, node1); auto dummy_channel2 = std::make_shared (node2, node2); ASSERT_NE (nano::transport::map_endpoint_to_v6 (dummy_channel1->get_endpoint ()), nano::transport::map_endpoint_to_v6 (dummy_channel2->get_endpoint ())); @@ -279,7 +279,7 @@ TEST (request_aggregator, split) .build ()); auto const & block = blocks.back (); previous = block->hash (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *block)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), block)); request.emplace_back (block->hash (), block->root ()); } // Confirm all blocks @@ -325,7 +325,7 @@ TEST (request_aggregator, channel_lifetime) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); { @@ -356,7 +356,7 @@ TEST (request_aggregator, channel_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); std::weak_ptr channel1_w; @@ -396,7 +396,7 @@ TEST (request_aggregator, channel_max_queue) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -424,7 +424,7 @@ TEST (request_aggregator, unique) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -464,8 +464,8 @@ TEST (request_aggregator, cannot_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2)); diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 1ef8be8d03..8ac65cc76b 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing) .work (0) .build (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); auto info2 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub); @@ -111,7 +111,7 @@ TEST (system, DISABLED_generate_send_new) .work (0) .build (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); std::vector accounts; diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index 03d322935a..cc95dd8461 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -168,12 +168,12 @@ TEST (vote_spacing, vote_generator) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); @@ -212,11 +212,11 @@ TEST (vote_spacing, rapid) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index e7c8356eb5..f52eb66695 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1114,7 +1114,7 @@ TEST (wallet, epoch_2_receive_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key.pub, node.network_params.work.epoch_2)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*epoch2_unopened)); + ASSERT_EQ (nano::block_status::progress, node.process (epoch2_unopened)); wallet.insert_adhoc (key.prv, false); @@ -1175,7 +1175,7 @@ TEST (wallet, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 5e3d45dfb8..38009cdb19 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -110,7 +110,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); auto open1 = builder .state () .account (key1.pub) @@ -121,7 +121,7 @@ TEST (wallets, vote_minimum) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); + ASSERT_EQ (nano::block_status::progress, node1.process (open1)); // send2 with amount vote_minimum - 1 (not voting representative) auto send2 = builder .state () @@ -133,7 +133,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); auto open2 = builder .state () .account (key2.pub) @@ -144,7 +144,7 @@ TEST (wallets, vote_minimum) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open2)); + ASSERT_EQ (nano::block_status::progress, node1.process (open2)); auto wallet (node1.wallets.items.begin ()->second); nano::unique_lock representatives_lk (wallet->representatives_mutex); ASSERT_EQ (0, wallet->representatives.size ()); @@ -212,7 +212,7 @@ TEST (wallets, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 89cff93745..64a899fab0 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1029,7 +1029,7 @@ int main (int argc, char * const * argv) .build (); genesis_latest = send->hash (); - node->ledger.process (transaction, *send); + node->ledger.process (transaction, send); auto open = builder.state () .account (keys[i].pub) @@ -1041,7 +1041,7 @@ int main (int argc, char * const * argv) .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); - node->ledger.process (transaction, *open); + node->ledger.process (transaction, open); } // Generating blocks std::deque> blocks; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 471a3ccb6d..f9e2430e02 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -314,9 +314,9 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock nano::block_status nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) { - auto const & block = context.block; + auto block = context.block; auto const hash = block->hash (); - nano::block_status result = node.ledger.process (transaction_a, *block); + nano::block_status result = node.ledger.process (transaction_a, block); node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result)); node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source)); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index fe55224fa8..8ff6205086 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -559,12 +559,12 @@ void nano::node::process_active (std::shared_ptr const & incoming) block_processor.add (incoming); } -[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, nano::block & block) +[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, std::shared_ptr block) { return ledger.process (transaction, block); } -nano::block_status nano::node::process (nano::block & block) +nano::block_status nano::node::process (std::shared_ptr block) { auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending }); return process (transaction, block); diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 247dd35ccf..7fdb5d069e 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -210,8 +210,8 @@ class node final : public std::enable_shared_from_this Creates a new write transaction and inserts `block' and returns result Transaction is comitted before function return */ - [[nodiscard]] nano::block_status process (nano::block & block); - [[nodiscard]] nano::block_status process (store::write_transaction const &, nano::block & block); + [[nodiscard]] nano::block_status process (std::shared_ptr block); + [[nodiscard]] nano::block_status process (store::write_transaction const &, std::shared_ptr block); nano::block_hash latest (nano::account const &); nano::uint128_t balance (nano::account const &); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index df9cd9b767..3a6d9b4dc1 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -424,8 +424,8 @@ TEST (wallet, create_send) bool error (false); auto send = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*send)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*send)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (send)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send)); } TEST (wallet, create_open_receive) @@ -458,8 +458,8 @@ TEST (wallet, create_open_receive) bool error (false); auto open = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*open)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open)); wallet->block_creation.block->clear (); wallet->block_creation.source->clear (); wallet->block_creation.receive->click (); @@ -473,8 +473,8 @@ TEST (wallet, create_open_receive) bool error2 (false); auto receive = std::make_shared (error2, tree2); ASSERT_FALSE (error2); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*receive)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*receive)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (receive)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive)); } TEST (wallet, create_change) @@ -501,8 +501,8 @@ TEST (wallet, create_change) bool error (false); auto change = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*change)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*change)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (change)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change)); } TEST (history, short_text) @@ -532,11 +532,11 @@ TEST (history, short_text) nano::keypair key; auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send = std::make_shared (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = std::make_shared (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto change = std::make_shared (receive->hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); } nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet); history.refresh (); @@ -572,13 +572,13 @@ TEST (history, pruned_source) store->initialize (transaction, ledger.cache, nano::dev::constants); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send1 = std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = std::make_shared (send1->hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive = std::make_shared (send2->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto open = std::make_shared (send2->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 2)); next_pruning = send2->hash (); } @@ -602,10 +602,10 @@ TEST (history, pruned_source) auto transaction (store->tx_begin_write ()); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send = std::make_shared (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto latest_key (ledger.latest (transaction, key.pub)); auto receive = std::make_shared (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest, 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 2)); } @@ -718,7 +718,7 @@ TEST (wallet, republish) auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); auto block = std::make_shared (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); hash = block->hash (); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block)); } auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); @@ -917,7 +917,7 @@ TEST (wallet, DISABLED_synchronizing) auto transaction (system1.nodes[0]->store.tx_begin_write ()); auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); auto send = std::make_shared (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); - system1.nodes[0]->ledger.process (transaction, *send); + system1.nodes[0]->ledger.process (transaction, send); } ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing)); system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ()); @@ -967,7 +967,7 @@ TEST (wallet, epoch_2_validation) bool error (false); auto block = std::make_shared (error, tree1); EXPECT_FALSE (error); - EXPECT_EQ (nano::block_status::progress, node->process (*block)); + EXPECT_EQ (nano::block_status::progress, node->process (block)); return block->hash (); }; diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 972dcbfa04..81563180d0 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -370,7 +370,7 @@ TEST (rpc, search_receivable) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index fd890c37a9..4f1c158f98 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -72,7 +72,7 @@ TEST (rpc, account_balance) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); ASSERT_TIMELY (5s, !node->active.active (*send1)); auto const rpc_ctx = add_rpc (system, node); @@ -152,7 +152,7 @@ TEST (rpc, account_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*block)); + ASSERT_EQ (nano::block_status::progress, node1->process (block)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_weight"); @@ -957,9 +957,9 @@ TEST (rpc, history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange)); } auto const rpc_ctx = add_rpc (system, node0); boost::property_tree::ptree request; @@ -1041,9 +1041,9 @@ TEST (rpc, account_history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange)); } auto const rpc_ctx = add_rpc (system, node0); { @@ -1557,8 +1557,8 @@ TEST (rpc, process_subtype_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto open = builder @@ -1606,8 +1606,8 @@ TEST (rpc, process_subtype_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto receive = builder @@ -2497,7 +2497,7 @@ TEST (rpc, bootstrap) .build (); { auto transaction (node1->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2782,7 +2782,7 @@ TEST (rpc, bootstrap_any) .build (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2808,7 +2808,7 @@ TEST (rpc, republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -2817,7 +2817,7 @@ TEST (rpc, republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "republish"); @@ -2998,7 +2998,7 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY (5s, node->block (send->hash ())); ASSERT_TIMELY (5s, !node->active.active (*send)); @@ -3531,7 +3531,7 @@ TEST (rpc, search_receivable_all) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -3563,7 +3563,7 @@ TEST (rpc, wallet_republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3572,7 +3572,7 @@ TEST (rpc, wallet_republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); @@ -3607,7 +3607,7 @@ TEST (rpc, delegators) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3616,7 +3616,7 @@ TEST (rpc, delegators) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators"); @@ -3648,7 +3648,7 @@ TEST (rpc, delegators_parameters) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3657,7 +3657,7 @@ TEST (rpc, delegators_parameters) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); // Test with "count" = 2 @@ -3758,7 +3758,7 @@ TEST (rpc, delegators_count) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3767,7 +3767,7 @@ TEST (rpc, delegators_count) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators_count"); @@ -3810,7 +3810,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto time = nano::seconds_since_epoch (); { auto transaction = node1->store.tx_begin_write (); @@ -3869,7 +3869,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -3878,7 +3878,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto state_change = builder .state () @@ -3890,7 +3890,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*state_change)); + ASSERT_EQ (nano::block_status::progress, node1->process (state_change)); auto open = builder .open () @@ -3900,7 +3900,7 @@ TEST (rpc, account_info) .sign (key1.prv, key1.pub) .work (*node1->work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); ASSERT_TIMELY (5s, !node1->active.active (*state_change)); ASSERT_TIMELY (5s, !node1->active.active (*open)); } @@ -4018,7 +4018,7 @@ TEST (rpc, json_block_output) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4240,7 +4240,7 @@ TEST (rpc, block_info_successor) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4430,7 +4430,7 @@ TEST (rpc, populate_backlog) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send)); + ASSERT_EQ (nano::block_status::progress, node->process (send)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4461,7 +4461,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send)); + ASSERT_EQ (nano::block_status::progress, node->process (send)); auto open = builder .open () .source (send->hash ()) @@ -4470,7 +4470,7 @@ TEST (rpc, ledger) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4544,7 +4544,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); // When asking for pending, pending amount is taken into account for threshold so the account must show up request.put ("count", 2); request.put ("threshold", (send_amount + send2_amount).convert_to ()); @@ -4631,7 +4631,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream, block_l); auto send_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (send->hash (), send_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); boost::property_tree::ptree request1; request1.put ("action", "block_create"); request1.put ("type", "open"); @@ -4649,7 +4649,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream1, block_l); auto open_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (open->hash (), open_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); request1.put ("representative", key.pub.to_account ()); auto response2 (wait_response (system, rpc_ctx, request1)); std::string open2_hash (response2.get ("hash")); @@ -4672,7 +4672,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream4, block_l); auto change_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (change->hash (), change_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*change)); + ASSERT_EQ (nano::block_status::progress, node1->process (change)); auto send2 = builder .send () .previous (send->hash ()) @@ -4681,7 +4681,7 @@ TEST (rpc, block_create) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); boost::property_tree::ptree request2; request2.put ("action", "block_create"); request2.put ("type", "receive"); @@ -4729,7 +4729,7 @@ TEST (rpc, block_create_state) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); } @@ -4765,7 +4765,7 @@ TEST (rpc, block_create_state_open) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4844,7 +4844,7 @@ TEST (rpc, block_create_open_epoch_v2) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4871,7 +4871,7 @@ TEST (rpc, block_create_receive_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); auto send_block_2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio)); auto const rpc_ctx = add_rpc (system, node); @@ -4896,7 +4896,7 @@ TEST (rpc, block_create_receive_epoch_v2) ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4924,7 +4924,7 @@ TEST (rpc, block_create_send_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); @@ -4947,7 +4947,7 @@ TEST (rpc, block_create_send_epoch_v2) ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_send); @@ -5048,7 +5048,7 @@ TEST (rpc, wallet_ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -5057,7 +5057,7 @@ TEST (rpc, wallet_ledger) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; @@ -5221,7 +5221,7 @@ TEST (rpc, confirmation_height_currently_processing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); previous_genesis_chain_hash = send->hash (); } @@ -5343,7 +5343,7 @@ TEST (rpc, block_confirm) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -5850,7 +5850,7 @@ TEST (rpc, block_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); auto open1 = builder .open () @@ -5860,7 +5860,7 @@ TEST (rpc, block_confirmed) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } // This should not be confirmed @@ -6144,7 +6144,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); // to opened account - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6155,7 +6155,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); // to unopened account (pending) - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6166,7 +6166,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6178,7 +6178,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); // to max account - ASSERT_EQ (nano::block_status::progress, node->process (*send4)); + ASSERT_EQ (nano::block_status::progress, node->process (send4)); auto open = builder .state () .account (key1.pub) @@ -6189,7 +6189,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6235,7 +6235,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send5)); + ASSERT_EQ (nano::block_status::progress, node->process (send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6246,7 +6246,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build (); // to key1 (again) - ASSERT_EQ (nano::block_status::progress, node->process (*send6)); + ASSERT_EQ (nano::block_status::progress, node->process (send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6258,7 +6258,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build (); // to key3 - ASSERT_EQ (nano::block_status::progress, node->process (*send7)); + ASSERT_EQ (nano::block_status::progress, node->process (send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6307,7 +6307,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); // to opened account - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6318,7 +6318,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); // to unopened account (pending) - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6329,7 +6329,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6341,7 +6341,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); // to max account - ASSERT_EQ (nano::block_status::progress, node->process (*send4)); + ASSERT_EQ (nano::block_status::progress, node->process (send4)); auto open = builder .state () .account (key1.pub) @@ -6352,7 +6352,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6399,7 +6399,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send5)); + ASSERT_EQ (nano::block_status::progress, node->process (send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6410,7 +6410,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build (); // to key1 (again) - ASSERT_EQ (nano::block_status::progress, node->process (*send6)); + ASSERT_EQ (nano::block_status::progress, node->process (send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6422,7 +6422,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build (); // to key3 - ASSERT_EQ (nano::block_status::progress, node->process (*send7)); + ASSERT_EQ (nano::block_status::progress, node->process (send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6471,7 +6471,7 @@ TEST (rpc, account_lazy_start) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -6480,7 +6480,7 @@ TEST (rpc, account_lazy_start) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // Start lazy bootstrap with account nano::node_config node_config = system.default_config (); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 62503f5c1d..c23ffc73b4 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -915,11 +915,11 @@ std::optional nano::ledger::pending_info (store::transaction return std::nullopt; } -nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, nano::block & block_a) +nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, std::shared_ptr block_a) { - debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis); + debug_assert (!constants.work.validate_entry (*block_a) || constants.genesis == nano::dev::genesis); ledger_processor processor (*this, transaction_a); - block_a.visit (processor); + block_a->visit (processor); if (processor.result == nano::block_status::progress) { ++cache.block_count; diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 9f3c69a571..935f57e2cb 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -72,7 +72,7 @@ class ledger final nano::block_hash block_source (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; - nano::block_status process (store::write_transaction const &, nano::block &); + nano::block_status process (store::write_transaction const & transaction, std::shared_ptr block); bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector> &); bool rollback (store::write_transaction const &, nano::block_hash const &); void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 9bfa3bddc2..1dd982e004 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -136,7 +136,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto sprevious (send->hash ()); auto rprevious (open->hash ()); for (auto i (0), n (100000); i != n; ++i) @@ -159,7 +159,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (sprevious)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); sprevious = send->hash (); auto receive = builder .receive () @@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (rprevious)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); rprevious = receive->hash (); if (i % 100 == 0) { @@ -277,7 +277,7 @@ TEST (node, fork_storm) previous = send->hash (); for (auto node_i : system.nodes) { - auto send_result (node_i->process (*send)); + auto send_result (node_i->process (send)); ASSERT_EQ (nano::block_status::progress, send_result); nano::keypair rep; auto open = builder @@ -289,7 +289,7 @@ TEST (node, fork_storm) .work (0) .build (); node_i->work_generate_blocking (*open); - auto open_result (node_i->process (*open)); + auto open_result (node_i->process (open)); ASSERT_EQ (nano::block_status::progress, open_result); auto transaction (node_i->store.tx_begin_read ()); node_i->network.flood_block (open); @@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (last_keypair.prv, last_keypair.pub) .work (*system.work.generate (last_open_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); last_open_hash = open->hash (); last_keypair = key; } @@ -744,7 +744,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -753,7 +753,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); } // Bulk send from genesis account to destination account @@ -845,7 +845,7 @@ TEST (confirmation_height, long_chains) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto receive = builder .receive () .previous (previous_destination_chain_hash) @@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains) .sign (key1.prv, key1.pub) .work (*system.work.generate (previous_destination_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive)); previous_genesis_chain_hash = send->hash (); previous_destination_chain_hash = receive->hash (); @@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); } // Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts @@ -970,7 +970,7 @@ TEST (confirmation_height, dynamic_algorithm) auto transaction = node->store.tx_begin_write (); for (auto const & block : state_blocks) { - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } } @@ -1031,7 +1031,7 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) .build (); latest_genesis = send->hash (); state_blocks.push_back (send); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); ++num; }; @@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -1125,7 +1125,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1263,7 +1263,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -1272,7 +1272,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1316,8 +1316,8 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .work (*system.work.generate (send_blocks.back ()->hash ())) .build ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send_blocks.back ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive_blocks.back ())); } } @@ -1688,7 +1688,7 @@ TEST (telemetry, many_nodes) for (auto node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } // This is the node which will request metrics from all other nodes @@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::block_status::progress, node.process (*block)); + ASSERT_EQ (nano::block_status::progress, node.process (block)); latest = block->hash (); info.pending_hash = block->hash (); } @@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::block_status::progress, node.process (*block)); + ASSERT_EQ (nano::block_status::progress, node.process (block)); } ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count); ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count); @@ -2042,7 +2042,7 @@ TEST (node, aggressive_flooding) { for (auto const & block : genesis_blocks) { - auto process_result (node_wallet.first->process (*block)); + auto process_result (node_wallet.first->process (block)); ASSERT_TRUE (nano::block_status::progress == process_result || nano::block_status::old == process_result); } ASSERT_EQ (node1.latest (nano::dev::genesis_key.pub), node_wallet.first->latest (nano::dev::genesis_key.pub)); @@ -2146,7 +2146,7 @@ TEST (node, wallet_create_block_confirm_conflicts) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); latest = send->hash (); } } diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index 611206eb7e..063000f33e 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -12,7 +12,7 @@ nano::test::context::ledger_context::ledger_context (std::dequeinitialize (tx, ledger_m.cache, ledger_m.constants); for (auto const & i : blocks_m) { - auto process_result = ledger_m.process (tx, *i); + auto process_result = ledger_m.process (tx, i); debug_assert (process_result == nano::block_status::progress); } } diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 35d86b4e7d..37e1376253 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -40,7 +40,7 @@ std::shared_ptr nano::test::system::add_node (nano::node_config cons auto node (std::make_shared (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++)); for (auto i : initialization_blocks) { - auto result = node->ledger.process (node->store.tx_begin_write (), *i); + auto result = node->ledger.process (node->store.tx_begin_write (), i); debug_assert (result == nano::block_status::progress); } debug_assert (!node->init_error ()); @@ -262,7 +262,7 @@ std::shared_ptr nano::test::upgrade_epoch (nano::work_pool & bool error{ true }; if (!ec && epoch) { - error = ledger_a.process (transaction, *epoch) != nano::block_status::progress; + error = ledger_a.process (transaction, epoch) != nano::block_status::progress; } return !error ? std::move (epoch) : nullptr; diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index d08ca37b5f..9d6d5bb76e 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -64,7 +64,7 @@ bool nano::test::process (nano::node & node, std::vector Date: Thu, 22 Feb 2024 16:11:30 +0000 Subject: [PATCH 101/190] Remove node::rep_block function that was only used in tests. (#4444) --- nano/core_test/node.cpp | 12 ------------ nano/core_test/wallet.cpp | 13 ------------- nano/node/node.cpp | 12 ------------ nano/node/node.hpp | 1 - 4 files changed, 38 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 4faa66e0bb..6edce227bd 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -115,18 +115,6 @@ TEST (node, balance) ASSERT_EQ (std::numeric_limits::max (), system.nodes[0]->ledger.account_balance (transaction, nano::dev::genesis_key.pub)); } -TEST (node, representative) -{ - nano::test::system system (1); - auto block1 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); - { - auto transaction (system.nodes[0]->store.tx_begin_read ()); - ASSERT_TRUE (system.nodes[0]->ledger.store.block.exists (transaction, block1)); - } - nano::keypair key; - ASSERT_TRUE (system.nodes[0]->rep_block (key.pub).is_zero ()); -} - TEST (node, send_unkeyed) { nano::test::system system (1); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index e7c8356eb5..c53b6c13c4 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -223,19 +223,6 @@ TEST (wallet, spend) ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub)); } -TEST (wallet, change) -{ - nano::test::system system (1); - system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - nano::keypair key2; - auto block1 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); - ASSERT_FALSE (block1.is_zero ()); - ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::dev::genesis_key.pub, key2.pub)); - auto block2 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); - ASSERT_FALSE (block2.is_zero ()); - ASSERT_NE (block1, block2); -} - TEST (wallet, partial_spend) { nano::test::system system (1); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index fe55224fa8..b2a590699d 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -744,18 +744,6 @@ nano::uint128_t nano::node::weight (nano::account const & account_a) return ledger.weight (account_a); } -nano::block_hash nano::node::rep_block (nano::account const & account_a) -{ - auto const transaction (store.tx_begin_read ()); - nano::block_hash result (0); - auto info = ledger.account_info (transaction, account_a); - if (info) - { - result = ledger.representative (transaction, info->head); - } - return result; -} - nano::uint128_t nano::node::minimum_principal_weight () { return online_reps.trended () / network_params.network.principal_weight_factor; diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 247dd35ccf..b26c452c2a 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -92,7 +92,6 @@ class node final : public std::enable_shared_from_this std::shared_ptr block (nano::block_hash const &); std::pair balance_pending (nano::account const &, bool only_confirmed); nano::uint128_t weight (nano::account const &); - nano::block_hash rep_block (nano::account const &); nano::uint128_t minimum_principal_weight (); void ongoing_rep_calculation (); void ongoing_bootstrap (); From e0a4fd86b9c07af59149a6378e61fd0bdea83501 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 22 Feb 2024 16:46:22 +0000 Subject: [PATCH 102/190] Documentation and code clarity improvements to work_pool unit tests (#4445) --- nano/core_test/work_pool.cpp | 91 ++++++++++++++++++++---------------- 1 file changed, 51 insertions(+), 40 deletions(-) diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 59ada8938c..63eae4cf7f 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -12,6 +12,7 @@ #include +// produce one proof of work for a block and check that its difficulty is higher than the base difficulty TEST (work, one) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; @@ -27,6 +28,7 @@ TEST (work, one) ASSERT_LT (nano::dev::network_params.work.threshold_base (block->work_version ()), nano::dev::network_params.work.difficulty (*block)); } +// create a work_pool with zero threads and check that pool.generate returns no result TEST (work, disabled) { nano::work_pool pool{ nano::dev::network_params.network, 0 }; @@ -34,6 +36,7 @@ TEST (work, disabled) ASSERT_FALSE (result.is_initialized ()); } +// create a block with bad pow then fix it and check that it validates TEST (work, validate) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; @@ -48,19 +51,19 @@ TEST (work, validate) .build (); ASSERT_LT (nano::dev::network_params.work.difficulty (*send_block), nano::dev::network_params.work.threshold_base (send_block->work_version ())); send_block->block_work_set (*pool.generate (send_block->root ())); - ASSERT_LT (nano::dev::network_params.work.threshold_base (send_block->work_version ()), nano::dev::network_params.work.difficulty (*send_block)); + ASSERT_GE (nano::dev::network_params.work.difficulty (*send_block), nano::dev::network_params.work.threshold_base (send_block->work_version ())); } +// repeatedly start and cancel a work calculation and check that the callback is eventually called TEST (work, cancel) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; - auto iterations (0); - auto done (false); + const nano::root key (1); + auto iterations = 0; + auto done = false; while (!done) { - nano::root key (1); - pool.generate ( - nano::work_version::work_1, key, nano::dev::network_params.work.base, [&done] (boost::optional work_a) { + pool.generate (nano::work_version::work_1, key, nano::dev::network_params.work.base, [&done] (boost::optional work_a) { done = !work_a; }); pool.cancel (key); @@ -69,7 +72,7 @@ TEST (work, cancel) } } -TEST (work, cancel_many) +TEST (work, cancel_one_out_of_many) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::root key1 (1); @@ -87,59 +90,66 @@ TEST (work, cancel_many) pool.cancel (key1); } +// check that opencl hardware offloading works TEST (work, opencl) { nano::logger logger; - bool error (false); + bool error = false; nano::opencl_environment environment (error); ASSERT_TRUE (!error || !nano::opencl_loaded); - if (!environment.platforms.empty () && !environment.platforms.begin ()->devices.empty ()) + + if (environment.platforms.empty () || environment.platforms.begin ()->devices.empty ()) { - nano::opencl_config config (0, 0, 16 * 1024); - auto opencl (nano::opencl_work::create (true, config, logger, nano::dev::network_params.work)); - if (opencl != nullptr) - { - // 0 threads, should add 1 for managing OpenCL - nano::work_pool pool{ nano::dev::network_params.network, 0, std::chrono::nanoseconds (0), [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { - return opencl->generate_work (version_a, root_a, difficulty_a); - } }; - ASSERT_NE (nullptr, pool.opencl); - nano::root root; - uint64_t difficulty (0xff00000000000000); - uint64_t difficulty_add (0x000f000000000000); - for (auto i (0); i < 16; ++i) - { - nano::random_pool::generate_block (root.bytes.data (), root.bytes.size ()); - auto result (*pool.generate (nano::work_version::work_1, root, difficulty)); - ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, result), difficulty); - difficulty += difficulty_add; - } - } - else - { - std::cerr << "Error starting OpenCL test" << std::endl; - } + GTEST_SKIP () << "Device with OpenCL support not found. Skipping OpenCL test" << std::endl; } - else + + nano::opencl_config config (0, 0, 16 * 1024); + auto opencl = nano::opencl_work::create (true, config, logger, nano::dev::network_params.work); + ASSERT_TRUE (opencl); + + // 0 threads, should add 1 for managing OpenCL + bool opencl_function_called = false; + nano::work_pool pool{ nano::dev::network_params.network, 0, std::chrono::nanoseconds (0), + [&opencl, &opencl_function_called] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { + opencl_function_called = true; + return opencl->generate_work (version_a, root_a, difficulty_a); + } }; + ASSERT_NE (nullptr, pool.opencl); + + nano::root root; + uint64_t difficulty (0xffff000000000000); + uint64_t difficulty_add (0x00000f0000000000); + for (auto i (0); i < 16; ++i) { - std::cout << "Device with OpenCL support not found. Skipping OpenCL test" << std::endl; + nano::random_pool::generate_block (root.bytes.data (), root.bytes.size ()); + auto nonce_opt = pool.generate (nano::work_version::work_1, root, difficulty); + ASSERT_TRUE (nonce_opt.has_value ()); + auto nonce = nonce_opt.get (); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, nonce), difficulty); + difficulty += difficulty_add; } + ASSERT_TRUE (opencl_function_called); } +// repeat difficulty calculations until a difficulty in a certain range is found TEST (work, difficulty) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; - nano::root root (1); - uint64_t difficulty1 (0xff00000000000000); - uint64_t difficulty2 (0xfff0000000000000); - uint64_t difficulty3 (0xffff000000000000); - uint64_t result_difficulty1 (0); + const nano::root root (1); + uint64_t difficulty1 = 0xff00000000000000; + uint64_t difficulty2 = 0xfff0000000000000; + uint64_t difficulty3 = 0xffff000000000000; + + // find a difficulty between difficulty1 and difficulty2 + uint64_t result_difficulty1 = 0; do { auto work1 = *pool.generate (nano::work_version::work_1, root, difficulty1); result_difficulty1 = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work1); } while (result_difficulty1 > difficulty2); ASSERT_GT (result_difficulty1, difficulty1); + + // find a difficulty between difficulty2 and difficulty3 uint64_t result_difficulty2 (0); do { @@ -149,6 +159,7 @@ TEST (work, difficulty) ASSERT_GT (result_difficulty2, difficulty2); } +// check that the pow_rate_limiter of work_pool works, this test can fail occasionally TEST (work, eco_pow) { auto work_func = [] (std::promise & promise, std::chrono::nanoseconds interval) { From 8d08259cbb656db4a538d4076178151381df7b30 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 19 Feb 2024 01:34:19 +0000 Subject: [PATCH 103/190] Re-enable unit test active_transactions.confirm_new (#4438) I am renabling this test. It is a trivial test and I can see no reason why it should not work. If it does not work, then we need to find out why. --- nano/core_test/active_transactions.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index c848ffe250..dc59f954f5 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1041,10 +1041,7 @@ TEST (active_transactions, confirmation_consistency) } } -// Test disabled because it's failing intermittently. -// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3629 -// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3634 -TEST (active_transactions, DISABLED_confirm_new) +TEST (active_transactions, confirm_new) { nano::test::system system (1); auto & node1 = *system.nodes[0]; @@ -1063,7 +1060,8 @@ TEST (active_transactions, DISABLED_confirm_new) // Let node2 know about the block ASSERT_TIMELY (5s, node2.block (send->hash ())); // Wait confirmation - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2); } // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache From 2526b75e61fc1fcb8b4daaf182ece15edafb5205 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 23 Feb 2024 17:41:50 +0000 Subject: [PATCH 104/190] Introduce opencl_work_func_t to make code more readable (#4446) --- nano/lib/work.cpp | 2 +- nano/lib/work.hpp | 8 ++++++-- nano/nano_node/daemon.cpp | 12 ++++++++---- nano/nano_node/entry.cpp | 14 +++++++++----- nano/nano_wallet/entry.cpp | 14 +++++++++----- nano/node/openclwork.hpp | 6 +++++- 6 files changed, 38 insertions(+), 18 deletions(-) diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 07b27e3979..480dba578c 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -23,7 +23,7 @@ std::string nano::to_string (nano::work_version const version_a) return result; } -nano::work_pool::work_pool (nano::network_constants & network_constants, unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> opencl_a) : +nano::work_pool::work_pool (nano::network_constants & network_constants, unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, nano::opencl_work_func_t opencl_a) : network_constants{ network_constants }, ticket (0), done (false), diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp index 70df3b8144..60f84987ec 100644 --- a/nano/lib/work.hpp +++ b/nano/lib/work.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include @@ -16,6 +17,9 @@ namespace nano { std::string to_string (nano::work_version const version_a); +// type of function that does the work generation with an optional return value +using opencl_work_func_t = std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)>; + class block; class block_details; enum class block_type : uint8_t; @@ -36,7 +40,7 @@ class work_item final class work_pool final { public: - work_pool (nano::network_constants & network_constants, unsigned, std::chrono::nanoseconds = std::chrono::nanoseconds (0), std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> = nullptr); + work_pool (nano::network_constants & network_constants, unsigned, std::chrono::nanoseconds = std::chrono::nanoseconds (0), nano::opencl_work_func_t = nullptr); ~work_pool (); void loop (uint64_t); void stop (); @@ -55,7 +59,7 @@ class work_pool final nano::mutex mutex{ mutex_identifier (mutexes::work_pool) }; nano::condition_variable producer_condition; std::chrono::nanoseconds pow_rate_limiter; - std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> opencl; + nano::opencl_work_func_t opencl; nano::observer_set work_observers; }; diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index fed22d3bcf..2becd930a5 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -99,11 +99,15 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag } boost::asio::io_context io_ctx; - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); - nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { - return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); + auto opencl = nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work); + nano::opencl_work_func_t opencl_work_func; + if (opencl) + { + opencl_work_func = [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { + return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); + }; } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); + nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl_work_func); try { // This avoids a blank prompt during any node initialization delays diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 64a899fab0..534c368adc 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -615,11 +615,15 @@ int main (int argc, char * const * argv) { nano::logger logger; nano::opencl_config config (platform, device, threads); - auto opencl (nano::opencl_work::create (true, config, logger, network_params.work)); - nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { - return opencl->generate_work (version_a, root_a, difficulty_a); - } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr) }; + auto opencl = nano::opencl_work::create (true, config, logger, network_params.work); + nano::opencl_work_func_t opencl_work_func; + if (opencl) + { + opencl_work_func = [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { + return opencl->generate_work (version_a, root_a, difficulty_a); + }; + } + nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl_work_func }; nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, nano::work_thresholds::publish_full.base), 4) % nano::work_thresholds::publish_full.base); for (uint64_t i (0); true; ++i) diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index ec15e6fb98..69d8262aa7 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -128,11 +128,15 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std:: std::shared_ptr node; std::shared_ptr gui; nano::set_application_icon (application); - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); - nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { - return opencl->generate_work (version_a, root_a, difficulty_a); - } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr) }; + auto opencl = nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work); + nano::opencl_work_func_t opencl_work_func; + if (opencl) + { + opencl_work_func = [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { + return opencl->generate_work (version_a, root_a, difficulty_a); + }; + } + nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl_work_func }; node = std::make_shared (io_ctx, data_path, config.node, work, flags); if (!node->init_error ()) { diff --git a/nano/node/openclwork.hpp b/nano/node/openclwork.hpp index 15173c1dcc..c73b988440 100644 --- a/nano/node/openclwork.hpp +++ b/nano/node/openclwork.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include @@ -22,12 +22,14 @@ namespace nano { extern bool opencl_loaded; class logger; + class opencl_platform { public: cl_platform_id platform; std::vector devices; }; + class opencl_environment { public: @@ -35,8 +37,10 @@ class opencl_environment void dump (std::ostream & stream); std::vector platforms; }; + class root; class work_pool; + class opencl_work { public: From 27973bc1be2706596f19bff2b21948e814b55ac9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 22 Feb 2024 17:00:12 +0100 Subject: [PATCH 105/190] Improve channel logging --- nano/node/transport/channel.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 26680ddc72..15b6e4acf9 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -67,5 +67,5 @@ void nano::transport::channel::operator() (nano::object_stream & obs) const { obs.write ("endpoint", get_endpoint ()); obs.write ("peering_endpoint", get_peering_endpoint ()); - obs.write ("node_id", get_node_id ()); + obs.write ("node_id", get_node_id ().to_node_id ()); } From efe7606e55c38c1f859d0c6ee41fbf0894e55da6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 13 Feb 2024 19:43:21 +0100 Subject: [PATCH 106/190] Organize members --- nano/node/repcrawler.cpp | 58 ++++++++++++++++---------------- nano/node/repcrawler.hpp | 72 +++++++++++++++++++++------------------- 2 files changed, 66 insertions(+), 64 deletions(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 8d7bb5ceee..a807ac68bc 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -25,7 +25,7 @@ void nano::rep_crawler::start () ongoing_crawl (); } -void nano::rep_crawler::validate () +void nano::rep_crawler::validate_and_process () { decltype (responses) responses_l; { @@ -107,7 +107,7 @@ void nano::rep_crawler::ongoing_crawl () auto now (std::chrono::steady_clock::now ()); auto total_weight_l (total_weight ()); cleanup_reps (); - validate (); + validate_and_process (); query (get_crawl_targets (total_weight_l)); auto sufficient_weight (total_weight_l > node.online_reps.delta ()); // If online weight drops below minimum, reach out to preconfigured peers @@ -127,7 +127,7 @@ void nano::rep_crawler::ongoing_crawl () }); } -std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t total_weight_a) +std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t total_weight_a) const { constexpr std::size_t conservative_count = 10; constexpr std::size_t aggressive_count = 40; @@ -175,15 +175,16 @@ void nano::rep_crawler::query (std::vectorfirst); + active.insert (hash_root->first); // TODO: Is this really necessary? } - for (auto i (channels_a.begin ()), n (channels_a.end ()); i != n; ++i) + for (const auto & channel : channels_a) { - debug_assert (*i != nullptr); - on_rep_request (*i); - node.network.send_confirm_req (*i, *hash_root); + debug_assert (channel != nullptr); + on_rep_request (channel); + node.network.send_confirm_req (channel, *hash_root); } + // TODO: Use a thread+timeout instead of a timer // A representative must respond with a vote within the deadline std::weak_ptr node_w (node.shared ()); node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root->first] () { @@ -197,11 +198,10 @@ void nano::rep_crawler::query (std::vector const & channel_a) { - std::vector> peers; - peers.emplace_back (channel_a); - query (peers); + query (std::vector{ channel_a }); } +// TODO: Use a thread+timeout instead of a timer void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint64_t const target_finished_processed) { if (node.vote_processor.total_processed >= target_finished_processed) @@ -224,23 +224,23 @@ bool nano::rep_crawler::is_pr (nano::transport::channel const & channel_a) const { nano::lock_guard lock{ probable_reps_mutex }; auto existing = probable_reps.get ().find (channel_a); - bool result = false; if (existing != probable_reps.get ().end ()) { - result = node.ledger.weight (existing->account) > node.minimum_principal_weight (); + return node.ledger.weight (existing->account) > node.minimum_principal_weight (); } - return result; + return false; } -bool nano::rep_crawler::response (std::shared_ptr const & channel_a, std::shared_ptr const & vote_a, bool force) +// TODO: Remove force parameter +bool nano::rep_crawler::response (std::shared_ptr const & channel, std::shared_ptr const & vote, bool force) { bool error = true; nano::lock_guard lock{ active_mutex }; - for (auto i = vote_a->hashes.begin (), n = vote_a->hashes.end (); i != n; ++i) + for (auto const & hash : vote->hashes) { - if (force || active.count (*i) != 0) + if (force || active.count (hash) != 0) { - responses.emplace_back (channel_a, vote_a); + responses.emplace_back (channel, vote); error = false; break; } @@ -252,11 +252,11 @@ nano::uint128_t nano::rep_crawler::total_weight () const { nano::lock_guard lock{ probable_reps_mutex }; nano::uint128_t result (0); - for (auto i (probable_reps.get ().begin ()), n (probable_reps.get ().end ()); i != n; ++i) + for (const auto & i : probable_reps.get ()) { - if (i->channel->alive ()) + if (i.channel->alive ()) { - result += node.ledger.weight (i->account); + result += node.ledger.weight (i.account); } } return result; @@ -267,7 +267,7 @@ void nano::rep_crawler::on_rep_request (std::shared_ptr lock{ probable_reps_mutex }; if (channel_a->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) { - probably_rep_t::index::type & channel_ref_index = probable_reps.get (); + auto & channel_ref_index = probable_reps.get (); // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) auto itr_pair = channel_ref_index.equal_range (*channel_a); @@ -308,7 +308,7 @@ void nano::rep_crawler::cleanup_reps () if (i->get_type () == nano::transport::transport_type::tcp) { auto find_channel (node.network.tcp_channels.find_channel (i->get_tcp_endpoint ())); - if (find_channel != nullptr && *find_channel == *static_cast (i.get ())) + if (find_channel != nullptr && *find_channel == *static_cast (i.get ())) // TODO: WTF { equal = true; } @@ -327,15 +327,15 @@ void nano::rep_crawler::cleanup_reps () std::vector nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) { - auto version_min (opt_version_min_a.value_or (node.network_params.network.protocol_version_min)); + auto version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); std::multimap> ordered; nano::lock_guard lock{ probable_reps_mutex }; - for (auto i (probable_reps.get ().begin ()), n (probable_reps.get ().end ()); i != n; ++i) + for (const auto & i : probable_reps.get ()) { - auto weight = node.ledger.weight (i->account); - if (weight > weight_a && i->channel->get_network_version () >= version_min) + auto weight = node.ledger.weight (i.account); + if (weight > weight_a && i.channel->get_network_version () >= version_min) { - ordered.insert ({ nano::amount{ weight }, *i }); + ordered.insert ({ nano::amount{ weight }, i }); } } std::vector result; @@ -354,7 +354,7 @@ std::vector nano::rep_crawler::principal_representatives ( std::vector> nano::rep_crawler::representative_endpoints (std::size_t count_a) { std::vector> result; - auto reps (representatives (count_a)); + auto reps = representatives (count_a); for (auto const & rep : reps) { result.push_back (rep.channel); diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 70561df031..7926e9a5a7 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -54,24 +54,13 @@ class rep_crawler final { friend std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); - // clang-format off - class tag_account {}; - class tag_channel_ref {}; - class tag_last_request {}; - class tag_sequenced {}; - - using probably_rep_t = boost::multi_index_container, mi::member>, - mi::sequenced>, - mi::ordered_non_unique, - mi::member>, - mi::hashed_non_unique, - mi::const_mem_fun, &representative::channel_ref>>>>; - // clang-format on + friend class active_transactions_confirm_election_by_request_Test; + friend class active_transactions_confirm_frontier_Test; + friend class rep_crawler_local_Test; + friend class node_online_reps_rep_crawler_Test; public: - rep_crawler (nano::node & node_a); + explicit rep_crawler (nano::node & node_a); /** Start crawling */ void start (); @@ -80,7 +69,7 @@ class rep_crawler final void remove (nano::block_hash const &); /** Remove block hash from with delay depending on vote processor size */ - void throttled_remove (nano::block_hash const &, uint64_t const); + void throttled_remove (nano::block_hash const &, uint64_t target_finished_processed); /** Attempt to determine if the peer manages one or more representative accounts */ void query (std::vector> const & channels_a); @@ -103,7 +92,7 @@ class rep_crawler final nano::uint128_t total_weight () const; /** Request a list of the top \p count_a known representatives in descending order of weight, with at least \p weight_a voting weight, and optionally with a minimum version \p opt_version_min_a */ - std::vector representatives (std::size_t count_a = std::numeric_limits::max (), nano::uint128_t const weight_a = 0, boost::optional const & opt_version_min_a = boost::none); + std::vector representatives (std::size_t count_a = std::numeric_limits::max (), nano::uint128_t weight_a = 0, boost::optional const & opt_version_min_a = boost::none); /** Request a list of the top \p count_a known principal representatives in descending order of weight, optionally with a minimum version \p opt_version_min_a */ std::vector principal_representatives (std::size_t count_a = std::numeric_limits::max (), boost::optional const & opt_version_min_a = boost::none); @@ -114,23 +103,18 @@ class rep_crawler final /** Total number of representatives */ std::size_t representative_count (); -private: +private: // Dependencies nano::node & node; - /** Protects the active-hash container */ - nano::mutex active_mutex; - - /** We have solicted votes for these random blocks */ - std::unordered_set active; - +private: // Validate responses to see if they're reps - void validate (); + void validate_and_process (); /** Called continuously to crawl for representatives */ void ongoing_crawl (); /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ - std::vector> get_crawl_targets (nano::uint128_t total_weight_a); + std::vector> get_crawl_targets (nano::uint128_t total_weight_a) const; /** When a rep request is made, this is called to update the last-request timestamp. */ void on_rep_request (std::shared_ptr const & channel_a); @@ -138,17 +122,35 @@ class rep_crawler final /** Clean representatives with inactive channels */ void cleanup_reps (); - /** Protects the probable_reps container */ - mutable nano::mutex probable_reps_mutex; +private: + // clang-format off + class tag_account {}; + class tag_channel_ref {}; + class tag_last_request {}; + class tag_sequenced {}; - /** Probable representatives */ - probably_rep_t probable_reps; + using ordered_probable_reps = boost::multi_index_container, mi::member>, + mi::sequenced>, + mi::ordered_non_unique, + mi::member>, + mi::hashed_non_unique, + mi::const_mem_fun, &representative::channel_ref>>>>; + // clang-format on - friend class active_transactions_confirm_election_by_request_Test; - friend class active_transactions_confirm_frontier_Test; - friend class rep_crawler_local_Test; - friend class node_online_reps_rep_crawler_Test; + /** Probable representatives */ + ordered_probable_reps probable_reps; +private: std::deque, std::shared_ptr>> responses; + + /** We have solicted votes for these random blocks */ + std::unordered_set active; + + /** Protects the active-hash container */ + mutable nano::mutex active_mutex; + /** Protects the probable_reps container */ + mutable nano::mutex probable_reps_mutex; }; } From 167fefef9bcb3093f256f8417d7a16b0a4e82dba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 15 Feb 2024 09:38:13 +0100 Subject: [PATCH 107/190] Single mutex --- nano/core_test/active_transactions.cpp | 16 +------- nano/core_test/node.cpp | 24 +++--------- nano/node/node.cpp | 2 +- nano/node/repcrawler.cpp | 53 ++++++++++++++++++++------ nano/node/repcrawler.hpp | 15 +++----- 5 files changed, 55 insertions(+), 55 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index dc59f954f5..d9c350162f 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -14,8 +14,6 @@ using namespace std::chrono_literals; -namespace nano -{ /* * Tests that an election can be confirmed as the result of a confirmation request * @@ -80,10 +78,7 @@ TEST (active_transactions, confirm_election_by_request) ASSERT_FALSE (peers.empty ()); // Add representative (node1) to disabled rep crawler of node2 - { - nano::lock_guard guard (node2.rep_crawler.probable_reps_mutex); - node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.cbegin ()); - } + node2.rep_crawler.force_add_rep (nano::dev::genesis_key.pub, *peers.cbegin ()); // Expect a vote to come back ASSERT_TIMELY (5s, election->votes ().size () >= 1); @@ -97,10 +92,7 @@ TEST (active_transactions, confirm_election_by_request) ASSERT_TIMELY (5s, nano::test::confirmed (node1, { send1 })); ASSERT_TIMELY (5s, nano::test::confirmed (node2, { send1 })); } -} -namespace nano -{ TEST (active_transactions, confirm_frontier) { nano::test::system system; @@ -144,10 +136,7 @@ TEST (active_transactions, confirm_frontier) // Add representative to disabled rep crawler auto peers (node2.network.random_set (1)); ASSERT_FALSE (peers.empty ()); - { - nano::lock_guard guard (node2.rep_crawler.probable_reps_mutex); - node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); - } + node2.rep_crawler.force_add_rep (nano::dev::genesis_key.pub, *peers.begin ()); ASSERT_EQ (nano::block_status::progress, node2.process (send)); ASSERT_TIMELY (5s, !node2.active.empty ()); @@ -160,7 +149,6 @@ TEST (active_transactions, confirm_frontier) ASSERT_TIMELY (5s, node2.active.empty ()); ASSERT_GT (election2->confirmation_request_count, 0u); } -} TEST (active_transactions, keep_local) { diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 35c06a9cfa..439c3dca9f 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2012,8 +2012,6 @@ TEST (node, online_reps) ASSERT_EQ (node1.config.online_weight_minimum, node1.online_reps.trended ()); } -namespace nano -{ TEST (node, online_reps_rep_crawler) { nano::test::system system; @@ -2026,14 +2024,10 @@ TEST (node, online_reps_rep_crawler) node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (0, node1.online_reps.online ()); // After inserting to rep crawler - { - nano::lock_guard guard{ node1.rep_crawler.probable_reps_mutex }; - node1.rep_crawler.active.insert (nano::dev::genesis->hash ()); - } + node1.rep_crawler.force_active (nano::dev::genesis->hash ()); node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); } -} TEST (node, online_reps_election) { @@ -3962,24 +3956,16 @@ TEST (rep_crawler, recently_confirmed) ASSERT_ALWAYS_EQ (0.5s, node1.rep_crawler.representative_count (), 0); } -namespace nano -{ -TEST (rep_crawler, local) +// Votes from local channels should be ignored +TEST (rep_crawler, ignore_local) { nano::test::system system; nano::node_flags flags; - flags.disable_rep_crawler = true; auto & node = *system.add_node (flags); auto loopback = std::make_shared (node, node); auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - { - nano::lock_guard guard{ node.rep_crawler.probable_reps_mutex }; - node.rep_crawler.active.insert (nano::dev::genesis->hash ()); - node.rep_crawler.responses.emplace_back (loopback, vote); - } - node.rep_crawler.validate (); - ASSERT_EQ (0, node.rep_crawler.representative_count ()); -} + node.rep_crawler.force_response (loopback, vote); + ASSERT_ALWAYS_EQ (0.5s, node.rep_crawler.representative_count (), 0); } // Test that a node configured with `enable_pruning` and `max_pruning_age = 1s` will automatically diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 834cabbd9f..5220777ae4 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -93,7 +93,7 @@ std::unique_ptr nano::collect_container_info (re { std::size_t count; { - nano::lock_guard guard{ rep_crawler.active_mutex }; + nano::lock_guard guard{ rep_crawler.mutex }; count = rep_crawler.active.size (); } diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index a807ac68bc..db944111b3 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -16,7 +16,7 @@ nano::rep_crawler::rep_crawler (nano::node & node_a) : void nano::rep_crawler::remove (nano::block_hash const & hash_a) { - nano::lock_guard lock{ active_mutex }; + nano::lock_guard lock{ mutex }; active.erase (hash_a); } @@ -29,7 +29,7 @@ void nano::rep_crawler::validate_and_process () { decltype (responses) responses_l; { - nano::lock_guard lock{ active_mutex }; + nano::lock_guard lock{ mutex }; responses_l.swap (responses); } @@ -65,7 +65,7 @@ void nano::rep_crawler::validate_and_process () auto updated = false; std::shared_ptr prev_channel; - nano::unique_lock lock{ probable_reps_mutex }; + nano::unique_lock lock{ mutex }; auto existing (probable_reps.find (vote->account)); if (existing != probable_reps.end ()) @@ -166,7 +166,7 @@ void nano::rep_crawler::query (std::vector lock{ active_mutex }; + nano::lock_guard lock{ mutex }; // Don't send same block multiple times in tests if (node.network_params.network.is_dev_network ()) { @@ -222,7 +222,7 @@ void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint6 bool nano::rep_crawler::is_pr (nano::transport::channel const & channel_a) const { - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; auto existing = probable_reps.get ().find (channel_a); if (existing != probable_reps.get ().end ()) { @@ -235,7 +235,7 @@ bool nano::rep_crawler::is_pr (nano::transport::channel const & channel_a) const bool nano::rep_crawler::response (std::shared_ptr const & channel, std::shared_ptr const & vote, bool force) { bool error = true; - nano::lock_guard lock{ active_mutex }; + nano::lock_guard lock{ mutex }; for (auto const & hash : vote->hashes) { if (force || active.count (hash) != 0) @@ -250,7 +250,7 @@ bool nano::rep_crawler::response (std::shared_ptr cons nano::uint128_t nano::rep_crawler::total_weight () const { - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; nano::uint128_t result (0); for (const auto & i : probable_reps.get ()) { @@ -264,7 +264,7 @@ nano::uint128_t nano::rep_crawler::total_weight () const void nano::rep_crawler::on_rep_request (std::shared_ptr const & channel_a) { - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; if (channel_a->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) { auto & channel_ref_index = probable_reps.get (); @@ -285,7 +285,7 @@ void nano::rep_crawler::cleanup_reps () std::vector> channels; { // Check known rep channels - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; auto iterator (probable_reps.get ().begin ()); while (iterator != probable_reps.get ().end ()) { @@ -319,7 +319,7 @@ void nano::rep_crawler::cleanup_reps () } if (!equal) { - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; probable_reps.get ().erase (*i); } } @@ -329,7 +329,9 @@ std::vector nano::rep_crawler::representatives (std::size_ { auto version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); std::multimap> ordered; - nano::lock_guard lock{ probable_reps_mutex }; + + nano::lock_guard lock{ mutex }; + for (const auto & i : probable_reps.get ()) { auto weight = node.ledger.weight (i.account); @@ -365,6 +367,33 @@ std::vector> nano::rep_crawler::repres /** Total number of representatives */ std::size_t nano::rep_crawler::representative_count () { - nano::lock_guard lock{ probable_reps_mutex }; + nano::lock_guard lock{ mutex }; return probable_reps.size (); } + +// Only for tests +void nano::rep_crawler::force_add_rep (const nano::account & account, const std::shared_ptr & channel) +{ + release_assert (node.network_params.network.is_dev_network ()); + nano::lock_guard lock{ mutex }; + probable_reps.emplace (nano::representative (account, channel)); +} + +// Only for tests +void nano::rep_crawler::force_response (const std::shared_ptr & channel, const std::shared_ptr & vote) +{ + release_assert (node.network_params.network.is_dev_network ()); + nano::lock_guard lock{ mutex }; + for (auto const & hash : vote->hashes) + { + responses.emplace_back (channel, vote); + } +} + +// Only for tests +void nano::rep_crawler::force_active (const nano::block_hash & hash) +{ + release_assert (node.network_params.network.is_dev_network ()); + nano::lock_guard lock{ mutex }; + active.insert (hash); +} \ No newline at end of file diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 7926e9a5a7..53d3cf4645 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -54,11 +54,6 @@ class rep_crawler final { friend std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); - friend class active_transactions_confirm_election_by_request_Test; - friend class active_transactions_confirm_frontier_Test; - friend class rep_crawler_local_Test; - friend class node_online_reps_rep_crawler_Test; - public: explicit rep_crawler (nano::node & node_a); @@ -148,9 +143,11 @@ class rep_crawler final /** We have solicted votes for these random blocks */ std::unordered_set active; - /** Protects the active-hash container */ - mutable nano::mutex active_mutex; - /** Protects the probable_reps container */ - mutable nano::mutex probable_reps_mutex; + mutable nano::mutex mutex; + +public: // Testing + void force_add_rep (nano::account const & account, std::shared_ptr const & channel); + void force_response (std::shared_ptr const & channel, std::shared_ptr const & vote); + void force_active (nano::block_hash const & hash); }; } From e820ed071ab9272738dd9fcfe9e49e7279d69f40 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 15 Feb 2024 10:51:48 +0100 Subject: [PATCH 108/190] Move collect_container_info into source file --- nano/node/node.cpp | 14 -------------- nano/node/node.hpp | 2 -- nano/node/repcrawler.cpp | 14 ++++++++++++++ nano/node/repcrawler.hpp | 2 ++ 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 5220777ae4..cea8a5a654 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -89,20 +89,6 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) }); } -std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) -{ - std::size_t count; - { - nano::lock_guard guard{ rep_crawler.mutex }; - count = rep_crawler.active.size (); - } - - auto const sizeof_element = sizeof (decltype (rep_crawler.active)::value_type); - auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "active", count, sizeof_element })); - return composite; -} - nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path) { auto node_private_key_path = application_path / "node_id_private.key"; diff --git a/nano/node/node.hpp b/nano/node/node.hpp index abd7b3651b..e3daaae82a 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -57,8 +57,6 @@ namespace scheduler class component; } -std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); - // Configs backlog_population::config backlog_population_config (node_config const &); outbound_bandwidth_limiter::config outbound_bandwidth_limiter_config (node_config const &); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index db944111b3..a1a654d7bf 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -396,4 +396,18 @@ void nano::rep_crawler::force_active (const nano::block_hash & hash) release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; active.insert (hash); +} + +std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) +{ + std::size_t count; + { + nano::lock_guard guard{ rep_crawler.mutex }; + count = rep_crawler.active.size (); + } + + auto const sizeof_element = sizeof (decltype (rep_crawler.active)::value_type); + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (container_info{ "active", count, sizeof_element })); + return composite; } \ No newline at end of file diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 53d3cf4645..32af6c2d52 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -150,4 +150,6 @@ class rep_crawler final void force_response (std::shared_ptr const & channel, std::shared_ptr const & vote); void force_active (nano::block_hash const & hash); }; + +std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); } From d867e5fe888622697c47f31d3f1189aee8f0fb1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 16 Feb 2024 12:28:03 +0100 Subject: [PATCH 109/190] Move rep_crawler tests to a dedicated file --- nano/core_test/CMakeLists.txt | 1 + nano/core_test/node.cpp | 250 ------------------------------- nano/core_test/rep_crawler.cpp | 264 +++++++++++++++++++++++++++++++++ nano/node/repcrawler.hpp | 1 + 4 files changed, 266 insertions(+), 250 deletions(-) create mode 100644 nano/core_test/rep_crawler.cpp diff --git a/nano/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt index 8f16a81f9e..ba92b42681 100644 --- a/nano/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -36,6 +36,7 @@ add_executable( optimistic_scheduler.cpp processing_queue.cpp processor_service.cpp + rep_crawler.cpp peer_container.cpp scheduler_buckets.cpp request_aggregator.cpp diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 439c3dca9f..55b6c6b2c9 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1597,256 +1597,6 @@ TEST (node, unconfirmed_send) ASSERT_TIMELY_EQ (5s, node1.balance (nano::dev::genesis->account ()), nano::dev::constants.genesis_amount); } -// Test that nodes can track nodes that have rep weight for priority broadcasting -TEST (node, rep_list) -{ - nano::test::system system (2); - auto & node1 (*system.nodes[1]); - auto wallet0 (system.wallet (0)); - auto wallet1 (system.wallet (1)); - // Node0 has a rep - wallet0->insert_adhoc (nano::dev::genesis_key.prv); - nano::keypair key1; - // Broadcast a confirm so others should know this is a rep node - wallet0->send_action (nano::dev::genesis_key.pub, key1.pub, nano::Mxrb_ratio); - ASSERT_EQ (0, node1.rep_crawler.representatives (1).size ()); - system.deadline_set (10s); - auto done (false); - while (!done) - { - auto reps = node1.rep_crawler.representatives (1); - if (!reps.empty ()) - { - if (!node1.ledger.weight (reps[0].account).is_zero ()) - { - done = true; - } - } - ASSERT_NO_ERROR (system.poll ()); - } -} - -TEST (node, rep_weight) -{ - nano::test::system system; - auto add_node = [&system] { - auto node = std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work); - node->start (); - system.nodes.push_back (node); - return node; - }; - auto & node = *add_node (); - auto & node1 = *add_node (); - auto & node2 = *add_node (); - auto & node3 = *add_node (); - nano::keypair keypair1; - nano::keypair keypair2; - nano::block_builder builder; - auto amount_pr (node.minimum_principal_weight () + 100); - auto amount_not_pr (node.minimum_principal_weight () - 100); - std::shared_ptr block1 = builder - .state () - .account (nano::dev::genesis_key.pub) - .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis_key.pub) - .balance (nano::dev::constants.genesis_amount - amount_not_pr) - .link (keypair1.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - std::shared_ptr block2 = builder - .state () - .account (keypair1.pub) - .previous (0) - .representative (keypair1.pub) - .balance (amount_not_pr) - .link (block1->hash ()) - .sign (keypair1.prv, keypair1.pub) - .work (*system.work.generate (keypair1.pub)) - .build (); - std::shared_ptr block3 = builder - .state () - .account (nano::dev::genesis_key.pub) - .previous (block1->hash ()) - .representative (nano::dev::genesis_key.pub) - .balance (nano::dev::constants.genesis_amount - amount_not_pr - amount_pr) - .link (keypair2.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (block1->hash ())) - .build (); - std::shared_ptr block4 = builder - .state () - .account (keypair2.pub) - .previous (0) - .representative (keypair2.pub) - .balance (amount_pr) - .link (block3->hash ()) - .sign (keypair2.prv, keypair2.pub) - .work (*system.work.generate (keypair2.pub)) - .build (); - { - auto transaction = node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block3)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4)); - } - ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); - std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); - ASSERT_NE (nullptr, channel1); - std::shared_ptr channel2 = nano::test::establish_tcp (system, node, node2.network.endpoint ()); - ASSERT_NE (nullptr, channel2); - std::shared_ptr channel3 = nano::test::establish_tcp (system, node, node3.network.endpoint ()); - ASSERT_NE (nullptr, channel3); - auto vote0 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - node.rep_crawler.response (channel1, vote0); - node.rep_crawler.response (channel2, vote1); - node.rep_crawler.response (channel3, vote2); - ASSERT_TIMELY_EQ (5s, node.rep_crawler.representative_count (), 2); - // Make sure we get the rep with the most weight first - auto reps = node.rep_crawler.representatives (1); - ASSERT_EQ (1, reps.size ()); - ASSERT_EQ (node.balance (nano::dev::genesis_key.pub), node.ledger.weight (reps[0].account)); - ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); - ASSERT_EQ (*channel1, reps[0].channel_ref ()); - ASSERT_TRUE (node.rep_crawler.is_pr (*channel1)); - ASSERT_FALSE (node.rep_crawler.is_pr (*channel2)); - ASSERT_TRUE (node.rep_crawler.is_pr (*channel3)); -} - -// Test that rep_crawler removes unreachable reps from its search results. -// This test creates three principal representatives (rep1, rep2, genesis_rep) and -// one node for searching them (searching_node). -TEST (node, rep_remove) -{ - nano::test::system system; - auto & searching_node = *system.add_node (); // will be used to find principal representatives - nano::keypair keys_rep1; // Principal representative 1 - nano::keypair keys_rep2; // Principal representative 2 - nano::block_builder builder; - - // Send enough nanos to Rep1 to make it a principal representative - std::shared_ptr send_to_rep1 = builder - .state () - .account (nano::dev::genesis_key.pub) - .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis_key.pub) - .balance (nano::dev::constants.genesis_amount - searching_node.minimum_principal_weight () * 2) - .link (keys_rep1.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - - // Receive by Rep1 - std::shared_ptr receive_rep1 = builder - .state () - .account (keys_rep1.pub) - .previous (0) - .representative (keys_rep1.pub) - .balance (searching_node.minimum_principal_weight () * 2) - .link (send_to_rep1->hash ()) - .sign (keys_rep1.prv, keys_rep1.pub) - .work (*system.work.generate (keys_rep1.pub)) - .build (); - - // Send enough nanos to Rep2 to make it a principal representative - std::shared_ptr send_to_rep2 = builder - .state () - .account (nano::dev::genesis_key.pub) - .previous (send_to_rep1->hash ()) - .representative (nano::dev::genesis_key.pub) - .balance (nano::dev::constants.genesis_amount - searching_node.minimum_principal_weight () * 4) - .link (keys_rep2.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (send_to_rep1->hash ())) - .build (); - - // Receive by Rep2 - std::shared_ptr receive_rep2 = builder - .state () - .account (keys_rep2.pub) - .previous (0) - .representative (keys_rep2.pub) - .balance (searching_node.minimum_principal_weight () * 2) - .link (send_to_rep2->hash ()) - .sign (keys_rep2.prv, keys_rep2.pub) - .work (*system.work.generate (keys_rep2.pub)) - .build (); - { - auto transaction = searching_node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep2)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep2)); - } - - // Create channel for Rep1 - auto channel_rep1 (std::make_shared (searching_node)); - - // Ensure Rep1 is found by the rep_crawler after receiving a vote from it - auto vote_rep1 = std::make_shared (keys_rep1.pub, keys_rep1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep1, vote_rep1, true)); - ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 1); - auto reps (searching_node.rep_crawler.representatives (1)); - ASSERT_EQ (1, reps.size ()); - ASSERT_EQ (searching_node.minimum_principal_weight () * 2, searching_node.ledger.weight (reps[0].account)); - ASSERT_EQ (keys_rep1.pub, reps[0].account); - ASSERT_EQ (*channel_rep1, reps[0].channel_ref ()); - - // When rep1 disconnects then rep1 should not be found anymore - channel_rep1->close (); - ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 0); - - // Add working node for genesis representative - auto node_genesis_rep = system.add_node (nano::node_config (system.get_available_port ())); - system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); - auto channel_genesis_rep (searching_node.network.find_node_id (node_genesis_rep->get_node_id ())); - ASSERT_NE (nullptr, channel_genesis_rep); - - // genesis_rep should be found as principal representative after receiving a vote from it - auto vote_genesis_rep = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - searching_node.rep_crawler.response (channel_genesis_rep, vote_genesis_rep, true); - ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); - - // Start a node for Rep2 and wait until it is connected - auto node_rep2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (system.get_available_port ()), system.work)); - node_rep2->start (); - searching_node.network.tcp_channels.start_tcp (node_rep2->network.endpoint ()); - std::shared_ptr channel_rep2; - ASSERT_TIMELY (10s, (channel_rep2 = searching_node.network.tcp_channels.find_node_id (node_rep2->get_node_id ())) != nullptr); - - // Rep2 should be found as a principal representative after receiving a vote from it - auto vote_rep2 = std::make_shared (keys_rep2.pub, keys_rep2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep2, vote_rep2, true)); - ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 2); - - // When Rep2 is stopped, it should not be found as principal representative anymore - node_rep2->stop (); - ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); - - // Now only genesisRep should be found: - reps = searching_node.rep_crawler.representatives (1); - ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); - ASSERT_TIMELY_EQ (5s, searching_node.network.size (), 1); - auto list (searching_node.network.list (1)); - ASSERT_EQ (node_genesis_rep->network.endpoint (), list[0]->get_endpoint ()); -} - -TEST (node, rep_connection_close) -{ - nano::test::system system (2); - auto & node1 (*system.nodes[0]); - auto & node2 (*system.nodes[1]); - // Add working representative (node 2) - system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); - ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 1); - node2.stop (); - // Remove representative with closed channel - ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 0); -} - // Test that nodes can disable representative voting TEST (node, no_voting) { diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp new file mode 100644 index 0000000000..745bfdb553 --- /dev/null +++ b/nano/core_test/rep_crawler.cpp @@ -0,0 +1,264 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +using namespace std::chrono_literals; + +// Test that nodes can track nodes that have rep weight for priority broadcasting +TEST (rep_crawler, rep_list) +{ + nano::test::system system (2); + auto & node1 (*system.nodes[1]); + auto wallet0 (system.wallet (0)); + auto wallet1 (system.wallet (1)); + // Node0 has a rep + wallet0->insert_adhoc (nano::dev::genesis_key.prv); + nano::keypair key1; + // Broadcast a confirm so others should know this is a rep node + wallet0->send_action (nano::dev::genesis_key.pub, key1.pub, nano::Mxrb_ratio); + ASSERT_EQ (0, node1.rep_crawler.representatives (1).size ()); + system.deadline_set (10s); + auto done (false); + while (!done) + { + auto reps = node1.rep_crawler.representatives (1); + if (!reps.empty ()) + { + if (!node1.ledger.weight (reps[0].account).is_zero ()) + { + done = true; + } + } + ASSERT_NO_ERROR (system.poll ()); + } +} + +TEST (rep_crawler, rep_weight) +{ + nano::test::system system; + auto add_node = [&system] { + auto node = std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work); + node->start (); + system.nodes.push_back (node); + return node; + }; + auto & node = *add_node (); + auto & node1 = *add_node (); + auto & node2 = *add_node (); + auto & node3 = *add_node (); + nano::keypair keypair1; + nano::keypair keypair2; + nano::block_builder builder; + auto amount_pr (node.minimum_principal_weight () + 100); + auto amount_not_pr (node.minimum_principal_weight () - 100); + std::shared_ptr block1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - amount_not_pr) + .link (keypair1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + std::shared_ptr block2 = builder + .state () + .account (keypair1.pub) + .previous (0) + .representative (keypair1.pub) + .balance (amount_not_pr) + .link (block1->hash ()) + .sign (keypair1.prv, keypair1.pub) + .work (*system.work.generate (keypair1.pub)) + .build (); + std::shared_ptr block3 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (block1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - amount_not_pr - amount_pr) + .link (keypair2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (block1->hash ())) + .build (); + std::shared_ptr block4 = builder + .state () + .account (keypair2.pub) + .previous (0) + .representative (keypair2.pub) + .balance (amount_pr) + .link (block3->hash ()) + .sign (keypair2.prv, keypair2.pub) + .work (*system.work.generate (keypair2.pub)) + .build (); + { + auto transaction = node.store.tx_begin_write (); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4)); + } + ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); + std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); + ASSERT_NE (nullptr, channel1); + std::shared_ptr channel2 = nano::test::establish_tcp (system, node, node2.network.endpoint ()); + ASSERT_NE (nullptr, channel2); + std::shared_ptr channel3 = nano::test::establish_tcp (system, node, node3.network.endpoint ()); + ASSERT_NE (nullptr, channel3); + auto vote0 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + node.rep_crawler.response (channel1, vote0); + node.rep_crawler.response (channel2, vote1); + node.rep_crawler.response (channel3, vote2); + ASSERT_TIMELY_EQ (5s, node.rep_crawler.representative_count (), 2); + // Make sure we get the rep with the most weight first + auto reps = node.rep_crawler.representatives (1); + ASSERT_EQ (1, reps.size ()); + ASSERT_EQ (node.balance (nano::dev::genesis_key.pub), node.ledger.weight (reps[0].account)); + ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); + ASSERT_EQ (*channel1, reps[0].channel_ref ()); + ASSERT_TRUE (node.rep_crawler.is_pr (*channel1)); + ASSERT_FALSE (node.rep_crawler.is_pr (*channel2)); + ASSERT_TRUE (node.rep_crawler.is_pr (*channel3)); +} + +// Test that rep_crawler removes unreachable reps from its search results. +// This test creates three principal representatives (rep1, rep2, genesis_rep) and +// one node for searching them (searching_node). +TEST (rep_crawler, rep_remove) +{ + nano::test::system system; + auto & searching_node = *system.add_node (); // will be used to find principal representatives + nano::keypair keys_rep1; // Principal representative 1 + nano::keypair keys_rep2; // Principal representative 2 + nano::block_builder builder; + + // Send enough nanos to Rep1 to make it a principal representative + std::shared_ptr send_to_rep1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - searching_node.minimum_principal_weight () * 2) + .link (keys_rep1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + + // Receive by Rep1 + std::shared_ptr receive_rep1 = builder + .state () + .account (keys_rep1.pub) + .previous (0) + .representative (keys_rep1.pub) + .balance (searching_node.minimum_principal_weight () * 2) + .link (send_to_rep1->hash ()) + .sign (keys_rep1.prv, keys_rep1.pub) + .work (*system.work.generate (keys_rep1.pub)) + .build (); + + // Send enough nanos to Rep2 to make it a principal representative + std::shared_ptr send_to_rep2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send_to_rep1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - searching_node.minimum_principal_weight () * 4) + .link (keys_rep2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send_to_rep1->hash ())) + .build (); + + // Receive by Rep2 + std::shared_ptr receive_rep2 = builder + .state () + .account (keys_rep2.pub) + .previous (0) + .representative (keys_rep2.pub) + .balance (searching_node.minimum_principal_weight () * 2) + .link (send_to_rep2->hash ()) + .sign (keys_rep2.prv, keys_rep2.pub) + .work (*system.work.generate (keys_rep2.pub)) + .build (); + { + auto transaction = searching_node.store.tx_begin_write (); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep2)); + } + + // Create channel for Rep1 + auto channel_rep1 (std::make_shared (searching_node)); + + // Ensure Rep1 is found by the rep_crawler after receiving a vote from it + auto vote_rep1 = std::make_shared (keys_rep1.pub, keys_rep1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep1, vote_rep1, true)); + ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 1); + auto reps (searching_node.rep_crawler.representatives (1)); + ASSERT_EQ (1, reps.size ()); + ASSERT_EQ (searching_node.minimum_principal_weight () * 2, searching_node.ledger.weight (reps[0].account)); + ASSERT_EQ (keys_rep1.pub, reps[0].account); + ASSERT_EQ (*channel_rep1, reps[0].channel_ref ()); + + // When rep1 disconnects then rep1 should not be found anymore + channel_rep1->close (); + ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 0); + + // Add working node for genesis representative + auto node_genesis_rep = system.add_node (nano::node_config (system.get_available_port ())); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); + auto channel_genesis_rep (searching_node.network.find_node_id (node_genesis_rep->get_node_id ())); + ASSERT_NE (nullptr, channel_genesis_rep); + + // genesis_rep should be found as principal representative after receiving a vote from it + auto vote_genesis_rep = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + searching_node.rep_crawler.response (channel_genesis_rep, vote_genesis_rep, true); + ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); + + // Start a node for Rep2 and wait until it is connected + auto node_rep2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (system.get_available_port ()), system.work)); + node_rep2->start (); + searching_node.network.tcp_channels.start_tcp (node_rep2->network.endpoint ()); + std::shared_ptr channel_rep2; + ASSERT_TIMELY (10s, (channel_rep2 = searching_node.network.tcp_channels.find_node_id (node_rep2->get_node_id ())) != nullptr); + + // Rep2 should be found as a principal representative after receiving a vote from it + auto vote_rep2 = std::make_shared (keys_rep2.pub, keys_rep2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep2, vote_rep2, true)); + ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 2); + + // When Rep2 is stopped, it should not be found as principal representative anymore + node_rep2->stop (); + ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); + + // Now only genesisRep should be found: + reps = searching_node.rep_crawler.representatives (1); + ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); + ASSERT_TIMELY_EQ (5s, searching_node.network.size (), 1); + auto list (searching_node.network.list (1)); + ASSERT_EQ (node_genesis_rep->network.endpoint (), list[0]->get_endpoint ()); +} + +TEST (rep_crawler, rep_connection_close) +{ + nano::test::system system (2); + auto & node1 (*system.nodes[0]); + auto & node2 (*system.nodes[1]); + // Add working representative (node 2) + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 1); + node2.stop (); + // Remove representative with closed channel + ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 0); +} \ No newline at end of file diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 32af6c2d52..1fabd2fe18 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include From 3cdee96c132cdee477bfbc2c295b2110cf043b93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Thu, 15 Feb 2024 11:55:17 +0100 Subject: [PATCH 110/190] Overhaul `rep_crawler` --- nano/core_test/node.cpp | 2 +- nano/lib/config.hpp | 5 + nano/lib/stats_enums.hpp | 4 + nano/lib/thread_roles.cpp | 3 + nano/lib/thread_roles.hpp | 1 + nano/node/node.cpp | 1 + nano/node/repcrawler.cpp | 290 +++++++++++++++++++++----------------- nano/node/repcrawler.hpp | 48 ++++--- 8 files changed, 205 insertions(+), 149 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 55b6c6b2c9..6a9b67eb8b 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1774,7 +1774,7 @@ TEST (node, online_reps_rep_crawler) node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (0, node1.online_reps.online ()); // After inserting to rep crawler - node1.rep_crawler.force_active (nano::dev::genesis->hash ()); + node1.rep_crawler.force_active_query (nano::dev::genesis->hash ()); node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); } diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index a68b02c1b0..6b59f1bc6e 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -251,6 +251,8 @@ class network_constants telemetry_request_interval = 500ms; telemetry_broadcast_interval = 500ms; optimistic_activation_delay = 2s; + rep_crawler_normal_interval = 500ms; + rep_crawler_warmup_interval = 500ms; } } @@ -307,6 +309,9 @@ class network_constants /** How much to delay activation of optimistic elections to avoid interfering with election scheduler */ std::chrono::seconds optimistic_activation_delay{ 30 }; + std::chrono::milliseconds rep_crawler_normal_interval{ 1000 * 7 }; + std::chrono::milliseconds rep_crawler_warmup_interval{ 1000 * 3 }; + /** Returns the network this object contains values for */ nano::networks network () const { diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 63c90bddc5..496d9f63cd 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -49,6 +49,7 @@ enum class type : uint8_t election_scheduler, optimistic_scheduler, handshake, + rep_crawler, bootstrap_ascending, bootstrap_ascending_accounts, @@ -328,6 +329,9 @@ enum class detail : uint8_t deprioritize, deprioritize_failed, + // rep_crawler + channel_dead, + _last // Must be the last enum }; diff --git a/nano/lib/thread_roles.cpp b/nano/lib/thread_roles.cpp index 0824d23733..e3f19d6ec4 100644 --- a/nano/lib/thread_roles.cpp +++ b/nano/lib/thread_roles.cpp @@ -100,6 +100,9 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) case nano::thread_role::name::scheduler_priority: thread_role_name_string = "Sched Priority"; break; + case nano::thread_role::name::rep_crawler: + thread_role_name_string = "Rep Crawler"; + break; default: debug_assert (false && "nano::thread_role::get_string unhandled thread role"); } diff --git a/nano/lib/thread_roles.hpp b/nano/lib/thread_roles.hpp index 311ae58d1b..8bc95c8329 100644 --- a/nano/lib/thread_roles.hpp +++ b/nano/lib/thread_roles.hpp @@ -42,6 +42,7 @@ enum class name scheduler_manual, scheduler_optimistic, scheduler_priority, + rep_crawler, }; /* diff --git a/nano/node/node.cpp b/nano/node/node.cpp index cea8a5a654..4bb58d41a1 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -664,6 +664,7 @@ void nano::node::stop () { ascendboot.stop (); } + rep_crawler.stop (); unchecked.stop (); block_processor.stop (); aggregator.stop (); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index a1a654d7bf..413d081a5a 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -4,73 +4,99 @@ #include nano::rep_crawler::rep_crawler (nano::node & node_a) : - node (node_a) + node{ node_a }, + stats{ node_a.stats }, + network_constants{ node_a.network_params.network }, + active{ node_a.active } { if (!node.flags.disable_rep_crawler) { - node.observers.endpoint.add ([this] (std::shared_ptr const & channel_a) { - this->query (channel_a); + node.observers.endpoint.add ([this] (std::shared_ptr const & channel) { + query (channel); }); } } -void nano::rep_crawler::remove (nano::block_hash const & hash_a) +nano::rep_crawler::~rep_crawler () { - nano::lock_guard lock{ mutex }; - active.erase (hash_a); + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); } void nano::rep_crawler::start () { - ongoing_crawl (); + debug_assert (!thread.joinable ()); + + thread = std::thread{ [this] () { + nano::thread_role::set (nano::thread_role::name::rep_crawler); + run (); + } }; } -void nano::rep_crawler::validate_and_process () +void nano::rep_crawler::stop () { - decltype (responses) responses_l; { nano::lock_guard lock{ mutex }; - responses_l.swap (responses); + stopped = true; } + condition.notify_all (); + if (thread.joinable ()) + { + thread.join (); + } +} + +void nano::rep_crawler::remove (nano::block_hash const & hash) +{ + nano::lock_guard lock{ mutex }; + queries.erase (hash); +} + +void nano::rep_crawler::validate_and_process (nano::unique_lock & lock) +{ + debug_assert (!mutex.try_lock ()); + debug_assert (lock.owns_lock ()); + + decltype (responses) responses_l; + responses_l.swap (responses); + + lock.unlock (); // normally the rep_crawler only tracks principal reps but it can be made to track // reps with less weight by setting rep_crawler_weight_minimum to a low value - auto minimum = std::min (node.minimum_principal_weight (), node.config.rep_crawler_weight_minimum.number ()); + auto const minimum = std::min (node.minimum_principal_weight (), node.config.rep_crawler_weight_minimum.number ()); - for (auto const & i : responses_l) + for (auto const & response : responses_l) { - auto & vote = i.second; - auto & channel = i.first; + auto & vote = response.second; + auto & channel = response.first; debug_assert (channel != nullptr); if (channel->get_type () == nano::transport::transport_type::loopback) { node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); - continue; } - nano::uint128_t rep_weight = node.ledger.weight (vote->account); + nano::uint128_t const rep_weight = node.ledger.weight (vote->account); if (rep_weight < minimum) { node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", vote->account.to_account (), nano::util::to_str (rep_weight)); - continue; } // temporary data used for logging after dropping the lock - auto inserted = false; - auto updated = false; + bool inserted = false; + bool updated = false; std::shared_ptr prev_channel; - nano::unique_lock lock{ mutex }; + lock.lock (); - auto existing (probable_reps.find (vote->account)); - if (existing != probable_reps.end ()) + if (auto existing = reps.find (vote->account); existing != reps.end ()) { - probable_reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (nano::representative & info) { + reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (nano::representative & info) { info.last_response = std::chrono::steady_clock::now (); // Update if representative channel was changed @@ -85,7 +111,7 @@ void nano::rep_crawler::validate_and_process () } else { - probable_reps.emplace (nano::representative (vote->account, channel)); + reps.emplace (nano::representative (vote->account, channel)); inserted = true; } @@ -102,39 +128,68 @@ void nano::rep_crawler::validate_and_process () } } -void nano::rep_crawler::ongoing_crawl () +void nano::rep_crawler::run () { - auto now (std::chrono::steady_clock::now ()); - auto total_weight_l (total_weight ()); - cleanup_reps (); - validate_and_process (); - query (get_crawl_targets (total_weight_l)); - auto sufficient_weight (total_weight_l > node.online_reps.delta ()); - // If online weight drops below minimum, reach out to preconfigured peers - if (!sufficient_weight) + nano::unique_lock lock{ mutex }; + while (!stopped) { - node.keepalive_preconfigured (node.config.preconfigured_peers); + lock.unlock (); + + auto const current_total_weight = total_weight (); + bool const sufficient_weight = current_total_weight > node.online_reps.delta (); + + // If online weight drops below minimum, reach out to preconfigured peers + if (!sufficient_weight) + { + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::keepalive); + node.keepalive_preconfigured (node.config.preconfigured_peers); + } + + lock.lock (); + + condition.wait_for (lock, sufficient_weight ? network_constants.rep_crawler_normal_interval : network_constants.rep_crawler_warmup_interval); + if (stopped) + { + return; + } + + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::loop); + + cleanup (); + + validate_and_process (lock); + debug_assert (!lock.owns_lock ()); + + auto targets = get_crawl_targets (current_total_weight); + query (targets); + + lock.lock (); } - // Reduce crawl frequency when there's enough total peer weight - unsigned next_run_ms = node.network_params.network.is_dev_network () ? 100 : sufficient_weight ? 7000 - : 3000; - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (now + std::chrono::milliseconds (next_run_ms), [node_w, this] () { - if (auto node_l = node_w.lock ()) +} + +void nano::rep_crawler::cleanup () +{ + debug_assert (!mutex.try_lock ()); + + erase_if (reps, [this] (representative const & rep) { + if (!rep.channel->alive ()) { - this->ongoing_crawl (); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::channel_dead); + return true; // Erase } + return false; }); } -std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t total_weight_a) const +std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t current_total_weight) const { + // TODO: Make these values configurable constexpr std::size_t conservative_count = 10; constexpr std::size_t aggressive_count = 40; // Crawl more aggressively if we lack sufficient total peer weight. - bool sufficient_weight (total_weight_a > node.online_reps.delta ()); - uint16_t required_peer_count = sufficient_weight ? conservative_count : aggressive_count; + bool sufficient_weight = current_total_weight > node.online_reps.delta (); + auto required_peer_count = sufficient_weight ? conservative_count : aggressive_count; // Add random peers. We do this even if we have enough weight, in order to pick up reps // that didn't respond when first observed. If the current total weight isn't sufficient, this @@ -143,51 +198,79 @@ std::vector> nano::rep_crawler::get_cr required_peer_count += required_peer_count / 2; // The rest of the endpoints are picked randomly - auto random_peers (node.network.random_set (required_peer_count, 0, true)); // Include channels with ephemeral remote ports - std::vector> result; - result.insert (result.end (), random_peers.begin (), random_peers.end ()); - return result; + auto random_peers = node.network.random_set (required_peer_count, 0, true); // Include channels with ephemeral remote ports + return { random_peers.begin (), random_peers.end () }; } -void nano::rep_crawler::query (std::vector> const & channels_a) +std::optional> nano::rep_crawler::prepare_query_target () { - auto transaction (node.store.tx_begin_read ()); + constexpr int max_attempts = 4; + + auto transaction = node.store.tx_begin_read (); + std::optional> hash_root; - for (auto i = 0; i < 4 && !hash_root; ++i) + + // Randomly select a block from ledger to request votes for + for (auto i = 0; i < max_attempts && !hash_root; ++i) { hash_root = node.ledger.hash_root_random (transaction); - if (node.active.recently_confirmed.exists (hash_root->first)) + + // Rebroadcasted votes for recently confirmed blocks might confuse the rep crawler + if (active.recently_confirmed.exists (hash_root->first)) { hash_root = std::nullopt; } } + if (!hash_root) { - return; + return std::nullopt; } + + // Don't send same block multiple times in tests + if (node.network_params.network.is_dev_network ()) { nano::lock_guard lock{ mutex }; - // Don't send same block multiple times in tests - if (node.network_params.network.is_dev_network ()) + + for (auto i = 0; queries.count (hash_root->first) != 0 && i < 4; ++i) { - for (auto i (0); active.count (hash_root->first) != 0 && i < 4; ++i) - { - hash_root = node.ledger.hash_root_random (transaction); - } + hash_root = node.ledger.hash_root_random (transaction); } - active.insert (hash_root->first); // TODO: Is this really necessary? } - for (const auto & channel : channels_a) + + if (!hash_root) + { + return std::nullopt; + } + + { + nano::lock_guard lock{ mutex }; + queries.insert (hash_root->first); + } + + return hash_root; +} + +void nano::rep_crawler::query (std::vector> const & target_channels) +{ + auto maybe_hash_root = prepare_query_target (); + if (!maybe_hash_root) + { + return; + } + auto hash_root = *maybe_hash_root; + + for (const auto & channel : target_channels) { debug_assert (channel != nullptr); on_rep_request (channel); - node.network.send_confirm_req (channel, *hash_root); + node.network.send_confirm_req (channel, hash_root); } // TODO: Use a thread+timeout instead of a timer // A representative must respond with a vote within the deadline std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root->first] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root.first] () { if (auto node_l = node_w.lock ()) { auto target_finished_processed (node_l->vote_processor.total_processed + node_l->vote_processor.size ()); @@ -196,9 +279,9 @@ void nano::rep_crawler::query (std::vector const & channel_a) +void nano::rep_crawler::query (std::shared_ptr const & target_channel) { - query (std::vector{ channel_a }); + query (std::vector{ target_channel }); } // TODO: Use a thread+timeout instead of a timer @@ -223,8 +306,8 @@ void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint6 bool nano::rep_crawler::is_pr (nano::transport::channel const & channel_a) const { nano::lock_guard lock{ mutex }; - auto existing = probable_reps.get ().find (channel_a); - if (existing != probable_reps.get ().end ()) + auto existing = reps.get ().find (channel_a); + if (existing != reps.get ().end ()) { return node.ledger.weight (existing->account) > node.minimum_principal_weight (); } @@ -238,7 +321,7 @@ bool nano::rep_crawler::response (std::shared_ptr cons nano::lock_guard lock{ mutex }; for (auto const & hash : vote->hashes) { - if (force || active.count (hash) != 0) + if (force || queries.count (hash) != 0) { responses.emplace_back (channel, vote); error = false; @@ -251,12 +334,12 @@ bool nano::rep_crawler::response (std::shared_ptr cons nano::uint128_t nano::rep_crawler::total_weight () const { nano::lock_guard lock{ mutex }; - nano::uint128_t result (0); - for (const auto & i : probable_reps.get ()) + nano::uint128_t result = 0; + for (const auto & rep : reps) { - if (i.channel->alive ()) + if (rep.channel->alive ()) { - result += node.ledger.weight (i.account); + result += node.ledger.weight (rep.account); } } return result; @@ -267,7 +350,7 @@ void nano::rep_crawler::on_rep_request (std::shared_ptr lock{ mutex }; if (channel_a->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) { - auto & channel_ref_index = probable_reps.get (); + auto & channel_ref_index = reps.get (); // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) auto itr_pair = channel_ref_index.equal_range (*channel_a); @@ -280,51 +363,6 @@ void nano::rep_crawler::on_rep_request (std::shared_ptr> channels; - { - // Check known rep channels - nano::lock_guard lock{ mutex }; - auto iterator (probable_reps.get ().begin ()); - while (iterator != probable_reps.get ().end ()) - { - if (iterator->channel->alive ()) - { - channels.push_back (iterator->channel); - ++iterator; - } - else - { - // Remove reps with closed channels - iterator = probable_reps.get ().erase (iterator); - } - } - } - // Remove reps with inactive channels - for (auto const & i : channels) - { - bool equal (false); - if (i->get_type () == nano::transport::transport_type::tcp) - { - auto find_channel (node.network.tcp_channels.find_channel (i->get_tcp_endpoint ())); - if (find_channel != nullptr && *find_channel == *static_cast (i.get ())) // TODO: WTF - { - equal = true; - } - } - else if (i->get_type () == nano::transport::transport_type::fake) - { - equal = true; - } - if (!equal) - { - nano::lock_guard lock{ mutex }; - probable_reps.get ().erase (*i); - } - } -} - std::vector nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) { auto version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); @@ -332,7 +370,7 @@ std::vector nano::rep_crawler::representatives (std::size_ nano::lock_guard lock{ mutex }; - for (const auto & i : probable_reps.get ()) + for (const auto & i : reps.get ()) { auto weight = node.ledger.weight (i.account); if (weight > weight_a && i.channel->get_network_version () >= version_min) @@ -368,7 +406,7 @@ std::vector> nano::rep_crawler::repres std::size_t nano::rep_crawler::representative_count () { nano::lock_guard lock{ mutex }; - return probable_reps.size (); + return reps.size (); } // Only for tests @@ -376,7 +414,7 @@ void nano::rep_crawler::force_add_rep (const nano::account & account, const std: { release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; - probable_reps.emplace (nano::representative (account, channel)); + reps.emplace (nano::representative (account, channel)); } // Only for tests @@ -391,11 +429,11 @@ void nano::rep_crawler::force_response (const std::shared_ptr lock{ mutex }; - active.insert (hash); + queries.insert (hash); } std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) @@ -403,11 +441,11 @@ std::unique_ptr nano::collect_container_info (re std::size_t count; { nano::lock_guard guard{ rep_crawler.mutex }; - count = rep_crawler.active.size (); + count = rep_crawler.queries.size (); } - auto const sizeof_element = sizeof (decltype (rep_crawler.active)::value_type); + auto const sizeof_element = sizeof (decltype (rep_crawler.queries)::value_type); auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "active", count, sizeof_element })); + composite->add_component (std::make_unique (container_info{ "queries", count, sizeof_element })); return composite; } \ No newline at end of file diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 1fabd2fe18..3a1664e0ea 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include @@ -13,6 +14,7 @@ #include #include +#include #include namespace mi = boost::multi_index; @@ -20,6 +22,7 @@ namespace mi = boost::multi_index; namespace nano { class node; +class active_transactions; /** * A representative picked up during repcrawl. @@ -57,9 +60,10 @@ class rep_crawler final public: explicit rep_crawler (nano::node & node_a); + ~rep_crawler (); - /** Start crawling */ void start (); + void stop (); /** Remove block hash from list of active rep queries */ void remove (nano::block_hash const &); @@ -68,10 +72,10 @@ class rep_crawler final void throttled_remove (nano::block_hash const &, uint64_t target_finished_processed); /** Attempt to determine if the peer manages one or more representative accounts */ - void query (std::vector> const & channels_a); + void query (std::vector> const & target_channels); /** Attempt to determine if the peer manages one or more representative accounts */ - void query (std::shared_ptr const & channel_a); + void query (std::shared_ptr const & target_channel); /** Query if a peer manages a principle representative */ bool is_pr (nano::transport::channel const &) const; @@ -101,55 +105,55 @@ class rep_crawler final private: // Dependencies nano::node & node; + nano::stats & stats; + nano::network_constants & network_constants; + nano::active_transactions & active; private: - // Validate responses to see if they're reps - void validate_and_process (); - - /** Called continuously to crawl for representatives */ - void ongoing_crawl (); + void run (); + void cleanup (); + void validate_and_process (nano::unique_lock &); /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ - std::vector> get_crawl_targets (nano::uint128_t total_weight_a) const; + std::vector> get_crawl_targets (nano::uint128_t current_total_weight) const; /** When a rep request is made, this is called to update the last-request timestamp. */ void on_rep_request (std::shared_ptr const & channel_a); - /** Clean representatives with inactive channels */ - void cleanup_reps (); + std::optional> prepare_query_target (); private: // clang-format off class tag_account {}; class tag_channel_ref {}; - class tag_last_request {}; class tag_sequenced {}; - using ordered_probable_reps = boost::multi_index_container, mi::member>, + mi::hashed_unique, + mi::member>, mi::sequenced>, - mi::ordered_non_unique, - mi::member>, mi::hashed_non_unique, mi::const_mem_fun, &representative::channel_ref>>>>; // clang-format on - /** Probable representatives */ - ordered_probable_reps probable_reps; + ordered_reps reps; private: - std::deque, std::shared_ptr>> responses; + /** We have solicited votes for these random blocks */ + std::unordered_set queries; - /** We have solicted votes for these random blocks */ - std::unordered_set active; + std::deque, std::shared_ptr>> responses; + bool stopped{ false }; + nano::condition_variable condition; mutable nano::mutex mutex; + std::thread thread; public: // Testing void force_add_rep (nano::account const & account, std::shared_ptr const & channel); void force_response (std::shared_ptr const & channel, std::shared_ptr const & vote); - void force_active (nano::block_hash const & hash); + void force_active_query (nano::block_hash const & hash); }; std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); From 3d803181ee84c66f989efa9d304a44953c206024 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 16 Feb 2024 12:40:47 +0100 Subject: [PATCH 111/190] Improve tests --- nano/core_test/rep_crawler.cpp | 69 ++++++++++++---------------------- nano/lib/logging_enums.hpp | 1 + nano/test_common/system.cpp | 2 + nano/test_common/testutil.cpp | 2 +- 4 files changed, 27 insertions(+), 47 deletions(-) diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 745bfdb553..082e72bf45 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -16,50 +16,30 @@ using namespace std::chrono_literals; // Test that nodes can track nodes that have rep weight for priority broadcasting TEST (rep_crawler, rep_list) { - nano::test::system system (2); - auto & node1 (*system.nodes[1]); - auto wallet0 (system.wallet (0)); - auto wallet1 (system.wallet (1)); - // Node0 has a rep - wallet0->insert_adhoc (nano::dev::genesis_key.prv); - nano::keypair key1; - // Broadcast a confirm so others should know this is a rep node - wallet0->send_action (nano::dev::genesis_key.pub, key1.pub, nano::Mxrb_ratio); - ASSERT_EQ (0, node1.rep_crawler.representatives (1).size ()); - system.deadline_set (10s); - auto done (false); - while (!done) - { - auto reps = node1.rep_crawler.representatives (1); - if (!reps.empty ()) - { - if (!node1.ledger.weight (reps[0].account).is_zero ()) - { - done = true; - } - } - ASSERT_NO_ERROR (system.poll ()); - } + nano::test::system system; + auto & node1 = *system.add_node (); + auto & node2 = *system.add_node (); + ASSERT_EQ (0, node2.rep_crawler.representative_count ()); + // Node #1 has a rep + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TIMELY_EQ (5s, node2.rep_crawler.representative_count (), 1); + auto reps = node2.rep_crawler.representatives (); + ASSERT_EQ (1, reps.size ()); + ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); } TEST (rep_crawler, rep_weight) { nano::test::system system; - auto add_node = [&system] { - auto node = std::make_shared (system.io_ctx, system.get_available_port (), nano::unique_path (), system.work); - node->start (); - system.nodes.push_back (node); - return node; - }; - auto & node = *add_node (); - auto & node1 = *add_node (); - auto & node2 = *add_node (); - auto & node3 = *add_node (); + auto & node = *system.add_node (); + auto & node1 = *system.add_node (); + auto & node2 = *system.add_node (); + auto & node3 = *system.add_node (); nano::keypair keypair1; nano::keypair keypair2; nano::block_builder builder; - auto amount_pr (node.minimum_principal_weight () + 100); - auto amount_not_pr (node.minimum_principal_weight () - 100); + auto const amount_pr = node.minimum_principal_weight () + 100; + auto const amount_not_pr = node.minimum_principal_weight () - 100; std::shared_ptr block1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -100,13 +80,10 @@ TEST (rep_crawler, rep_weight) .sign (keypair2.prv, keypair2.pub) .work (*system.work.generate (keypair2.pub)) .build (); - { - auto transaction = node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block3)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4)); - } + ASSERT_TRUE (nano::test::process (node, { block1, block2, block3, block4 })); + ASSERT_TRUE (nano::test::process (node1, { block1, block2, block3, block4 })); + ASSERT_TRUE (nano::test::process (node2, { block1, block2, block3, block4 })); + ASSERT_TRUE (nano::test::process (node3, { block1, block2, block3, block4 })); ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); ASSERT_NE (nullptr, channel1); @@ -252,9 +229,9 @@ TEST (rep_crawler, rep_remove) TEST (rep_crawler, rep_connection_close) { - nano::test::system system (2); - auto & node1 (*system.nodes[0]); - auto & node2 (*system.nodes[1]); + nano::test::system system; + auto & node1 = *system.add_node (); + auto & node2 = *system.add_node (); // Add working representative (node 2) system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 1); diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index d3df7ed774..33d40a3ce1 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -25,6 +25,7 @@ enum class type generic, test, + system, init, config, logging, diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 37e1376253..bf03c431d5 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -122,6 +122,8 @@ std::shared_ptr nano::test::system::add_node (nano::node_config cons debug_assert (!ec); } + logger.debug (nano::log::type::system, "Node started: {}", node->get_node_id ().to_node_id ()); + return node; } diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 9d6d5bb76e..bfe87b08d3 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -65,7 +65,7 @@ bool nano::test::process (nano::node & node, std::vector Date: Sat, 17 Feb 2024 19:16:12 +0100 Subject: [PATCH 112/190] Simplify `nano::representative` struct --- nano/core_test/confirmation_solicitor.cpp | 4 +- nano/core_test/rep_crawler.cpp | 4 +- nano/node/repcrawler.cpp | 30 ++++------- nano/node/repcrawler.hpp | 65 +++++++++++++---------- 4 files changed, 50 insertions(+), 53 deletions(-) diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index c47ae54e88..0e0dfdd05f 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -20,7 +20,7 @@ TEST (confirmation_solicitor, batches) auto & node2 = *system.add_node (node_flags); auto channel1 = nano::test::establish_tcp (system, node2, node1.network.endpoint ()); // Solicitor will only solicit from this representative - nano::representative representative (nano::dev::genesis_key.pub, channel1); + nano::representative representative{ nano::dev::genesis_key.pub, channel1 }; std::vector representatives{ representative }; nano::confirmation_solicitor solicitor (node2.network, node2.config); solicitor.prepare (representatives); @@ -70,7 +70,7 @@ TEST (confirmation_solicitor, different_hash) auto & node2 = *system.add_node (node_flags); auto channel1 = nano::test::establish_tcp (system, node2, node1.network.endpoint ()); // Solicitor will only solicit from this representative - nano::representative representative (nano::dev::genesis_key.pub, channel1); + nano::representative representative{ nano::dev::genesis_key.pub, channel1 }; std::vector representatives{ representative }; nano::confirmation_solicitor solicitor (node2.network, node2.config); solicitor.prepare (representatives); diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 082e72bf45..d9ae331645 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -103,7 +103,7 @@ TEST (rep_crawler, rep_weight) ASSERT_EQ (1, reps.size ()); ASSERT_EQ (node.balance (nano::dev::genesis_key.pub), node.ledger.weight (reps[0].account)); ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); - ASSERT_EQ (*channel1, reps[0].channel_ref ()); + ASSERT_EQ (*channel1, *reps[0].channel); ASSERT_TRUE (node.rep_crawler.is_pr (*channel1)); ASSERT_FALSE (node.rep_crawler.is_pr (*channel2)); ASSERT_TRUE (node.rep_crawler.is_pr (*channel3)); @@ -186,7 +186,7 @@ TEST (rep_crawler, rep_remove) ASSERT_EQ (1, reps.size ()); ASSERT_EQ (searching_node.minimum_principal_weight () * 2, searching_node.ledger.weight (reps[0].account)); ASSERT_EQ (keys_rep1.pub, reps[0].account); - ASSERT_EQ (*channel_rep1, reps[0].channel_ref ()); + ASSERT_EQ (*channel_rep1, *reps[0].channel); // When rep1 disconnects then rep1 should not be found anymore channel_rep1->close (); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 413d081a5a..a0968fa958 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -96,7 +96,7 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l if (auto existing = reps.find (vote->account); existing != reps.end ()) { - reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (nano::representative & info) { + reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (representative_entry & info) { info.last_response = std::chrono::steady_clock::now (); // Update if representative channel was changed @@ -111,7 +111,7 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l } else { - reps.emplace (nano::representative (vote->account, channel)); + reps.emplace (representative_entry{ vote->account, channel }); inserted = true; } @@ -171,7 +171,7 @@ void nano::rep_crawler::cleanup () { debug_assert (!mutex.try_lock ()); - erase_if (reps, [this] (representative const & rep) { + erase_if (reps, [this] (representative_entry const & rep) { if (!rep.channel->alive ()) { stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::channel_dead); @@ -356,8 +356,8 @@ void nano::rep_crawler::on_rep_request (std::shared_ptr nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) { - auto version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); - std::multimap> ordered; + auto const version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); nano::lock_guard lock{ mutex }; + std::multimap> ordered; for (const auto & i : reps.get ()) { auto weight = node.ledger.weight (i.account); @@ -378,10 +378,11 @@ std::vector nano::rep_crawler::representatives (std::size_ ordered.insert ({ nano::amount{ weight }, i }); } } + std::vector result; for (auto i = ordered.begin (), n = ordered.end (); i != n && result.size () < count_a; ++i) { - result.push_back (i->second); + result.push_back ({ i->second.account, i->second.channel }); } return result; } @@ -391,17 +392,6 @@ std::vector nano::rep_crawler::principal_representatives ( return representatives (count_a, node.minimum_principal_weight (), opt_version_min_a); } -std::vector> nano::rep_crawler::representative_endpoints (std::size_t count_a) -{ - std::vector> result; - auto reps = representatives (count_a); - for (auto const & rep : reps) - { - result.push_back (rep.channel); - } - return result; -} - /** Total number of representatives */ std::size_t nano::rep_crawler::representative_count () { @@ -414,7 +404,7 @@ void nano::rep_crawler::force_add_rep (const nano::account & account, const std: { release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; - reps.emplace (nano::representative (account, channel)); + reps.emplace (representative_entry{ account, channel }); } // Only for tests diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 3a1664e0ea..e824025179 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -24,30 +24,10 @@ namespace nano class node; class active_transactions; -/** - * A representative picked up during repcrawl. - */ -class representative +struct representative { -public: - representative () = default; - representative (nano::account account_a, std::shared_ptr const & channel_a) : - account (account_a), channel (channel_a) - { - debug_assert (channel != nullptr); - } - std::reference_wrapper channel_ref () const - { - return *channel; - }; - bool operator== (nano::representative const & other_a) const - { - return account == other_a.account; - } - nano::account account{}; + nano::account account; std::shared_ptr channel; - std::chrono::steady_clock::time_point last_request{ std::chrono::steady_clock::time_point () }; - std::chrono::steady_clock::time_point last_response{ std::chrono::steady_clock::time_point () }; }; /** @@ -59,7 +39,7 @@ class rep_crawler final friend std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); public: - explicit rep_crawler (nano::node & node_a); + explicit rep_crawler (nano::node &); ~rep_crawler (); void start (); @@ -97,9 +77,6 @@ class rep_crawler final /** Request a list of the top \p count_a known principal representatives in descending order of weight, optionally with a minimum version \p opt_version_min_a */ std::vector principal_representatives (std::size_t count_a = std::numeric_limits::max (), boost::optional const & opt_version_min_a = boost::none); - /** Request a list of the top \p count_a known representative endpoints. */ - std::vector> representative_endpoints (std::size_t count_a); - /** Total number of representatives */ std::size_t representative_count (); @@ -123,18 +100,48 @@ class rep_crawler final std::optional> prepare_query_target (); private: + /** + * A representative picked up during repcrawl. + */ + struct representative_entry + { + representative_entry (nano::account account_a, std::shared_ptr const & channel_a) : + account{ account_a }, + channel{ channel_a } + { + debug_assert (channel != nullptr); + } + + nano::account const account; + std::shared_ptr channel; + + std::chrono::steady_clock::time_point last_request{}; + std::chrono::steady_clock::time_point last_response{}; + + nano::account get_account () const + { + return account; + } + + std::reference_wrapper channel_ref () const + { + return *channel; + }; + }; + // clang-format off class tag_account {}; class tag_channel_ref {}; class tag_sequenced {}; - using ordered_reps = boost::multi_index_container, - mi::member>, + mi::const_mem_fun>, mi::sequenced>, mi::hashed_non_unique, - mi::const_mem_fun, &representative::channel_ref>>>>; + mi::const_mem_fun, &representative_entry::channel_ref>> + >>; // clang-format on ordered_reps reps; From fb516f33ab0a6995083e3d444f36f45a3b4597ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 19 Feb 2024 21:59:10 +0100 Subject: [PATCH 113/190] Use pointer as channel identity --- nano/core_test/rep_crawler.cpp | 6 +++--- nano/node/network.cpp | 2 +- nano/node/repcrawler.cpp | 19 +++++++++---------- nano/node/repcrawler.hpp | 13 ++++--------- 4 files changed, 17 insertions(+), 23 deletions(-) diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index d9ae331645..4b175cb358 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -104,9 +104,9 @@ TEST (rep_crawler, rep_weight) ASSERT_EQ (node.balance (nano::dev::genesis_key.pub), node.ledger.weight (reps[0].account)); ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); ASSERT_EQ (*channel1, *reps[0].channel); - ASSERT_TRUE (node.rep_crawler.is_pr (*channel1)); - ASSERT_FALSE (node.rep_crawler.is_pr (*channel2)); - ASSERT_TRUE (node.rep_crawler.is_pr (*channel3)); + ASSERT_TRUE (node.rep_crawler.is_pr (channel1)); + ASSERT_FALSE (node.rep_crawler.is_pr (channel2)); + ASSERT_TRUE (node.rep_crawler.is_pr (channel3)); } // Test that rep_crawler removes unreachable reps from its search results. diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 4d47533be6..ca56cccc95 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -419,7 +419,7 @@ std::deque> nano::network::list_non_pr tcp_channels.list (result); nano::random_pool_shuffle (result.begin (), result.end ()); result.erase (std::remove_if (result.begin (), result.end (), [this] (std::shared_ptr const & channel) { - return this->node.rep_crawler.is_pr (*channel); + return node.rep_crawler.is_pr (channel); }), result.end ()); if (result.size () > count_a) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index a0968fa958..c6014100e7 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -303,11 +303,11 @@ void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint6 } } -bool nano::rep_crawler::is_pr (nano::transport::channel const & channel_a) const +bool nano::rep_crawler::is_pr (std::shared_ptr const & channel) const { nano::lock_guard lock{ mutex }; - auto existing = reps.get ().find (channel_a); - if (existing != reps.get ().end ()) + auto existing = reps.get ().find (channel); + if (existing != reps.get ().end ()) { return node.ledger.weight (existing->account) > node.minimum_principal_weight (); } @@ -345,18 +345,17 @@ nano::uint128_t nano::rep_crawler::total_weight () const return result; } -void nano::rep_crawler::on_rep_request (std::shared_ptr const & channel_a) +void nano::rep_crawler::on_rep_request (std::shared_ptr const & channel) { nano::lock_guard lock{ mutex }; - if (channel_a->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) + if (channel->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) { - auto & channel_ref_index = reps.get (); - // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) - auto itr_pair = channel_ref_index.equal_range (*channel_a); - for (; itr_pair.first != itr_pair.second; itr_pair.first++) + auto & index = reps.get (); + auto [begin, end] = index.equal_range (channel); + for (auto it = begin; it != end; ++it) { - channel_ref_index.modify (itr_pair.first, [] (representative_entry & info) { + index.modify (it, [] (representative_entry & info) { info.last_request = std::chrono::steady_clock::now (); }); } diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index e824025179..666c618e34 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -58,7 +58,7 @@ class rep_crawler final void query (std::shared_ptr const & target_channel); /** Query if a peer manages a principle representative */ - bool is_pr (nano::transport::channel const &) const; + bool is_pr (std::shared_ptr const &) const; /** * Called when a non-replay vote on a block previously sent by query() is received. This indicates @@ -122,16 +122,11 @@ class rep_crawler final { return account; } - - std::reference_wrapper channel_ref () const - { - return *channel; - }; }; // clang-format off class tag_account {}; - class tag_channel_ref {}; + class tag_channel {}; class tag_sequenced {}; using ordered_reps = boost::multi_index_container, mi::const_mem_fun>, mi::sequenced>, - mi::hashed_non_unique, - mi::const_mem_fun, &representative_entry::channel_ref>> + mi::hashed_non_unique, + mi::member, &representative_entry::channel>> >>; // clang-format on From 8c8026ddfe0cb44f70fc445b4c6d089b3d437027 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 19 Feb 2024 21:44:20 +0100 Subject: [PATCH 114/190] Rework `rep_crawler::process ()` --- nano/core_test/election.cpp | 2 +- nano/core_test/node.cpp | 4 ++-- nano/core_test/rep_crawler.cpp | 12 ++++++------ nano/node/node.cpp | 9 +++++---- nano/node/repcrawler.cpp | 15 ++++++--------- nano/node/repcrawler.hpp | 18 +++++++++--------- 6 files changed, 29 insertions(+), 31 deletions(-) diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index fc193cc659..ec37d91371 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -254,7 +254,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) ASSERT_NE (channel, nullptr); auto vote2 = nano::test::make_final_vote (key1, { send1->hash () }); - ASSERT_FALSE (node1.rep_crawler.response (channel, vote2, true)); + node1.rep_crawler.force_process (vote2, channel); ASSERT_FALSE (election->confirmed ()); { diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 6a9b67eb8b..defbadb8bd 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1126,7 +1126,7 @@ TEST (node, DISABLED_fork_stale) auto channel = nano::test::establish_tcp (system1, node2, node1.network.endpoint ()); auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector ()); - node2.rep_crawler.response (channel, vote); + ASSERT_TRUE (node2.rep_crawler.process (vote, channel)); nano::keypair key1; nano::keypair key2; nano::state_block_builder builder; @@ -3714,7 +3714,7 @@ TEST (rep_crawler, ignore_local) auto & node = *system.add_node (flags); auto loopback = std::make_shared (node, node); auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - node.rep_crawler.force_response (loopback, vote); + node.rep_crawler.force_process (vote, loopback); ASSERT_ALWAYS_EQ (0.5s, node.rep_crawler.representative_count (), 0); } diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 4b175cb358..9b83ebc64c 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -94,9 +94,9 @@ TEST (rep_crawler, rep_weight) auto vote0 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - node.rep_crawler.response (channel1, vote0); - node.rep_crawler.response (channel2, vote1); - node.rep_crawler.response (channel3, vote2); + ASSERT_TRUE (node.rep_crawler.process (vote0, channel1)); + ASSERT_TRUE (node.rep_crawler.process (vote1, channel2)); + ASSERT_TRUE (node.rep_crawler.process (vote2, channel3)); ASSERT_TIMELY_EQ (5s, node.rep_crawler.representative_count (), 2); // Make sure we get the rep with the most weight first auto reps = node.rep_crawler.representatives (1); @@ -180,7 +180,7 @@ TEST (rep_crawler, rep_remove) // Ensure Rep1 is found by the rep_crawler after receiving a vote from it auto vote_rep1 = std::make_shared (keys_rep1.pub, keys_rep1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep1, vote_rep1, true)); + searching_node.rep_crawler.force_process (vote_rep1, channel_rep1); ASSERT_TIMELY_EQ (5s, searching_node.rep_crawler.representative_count (), 1); auto reps (searching_node.rep_crawler.representatives (1)); ASSERT_EQ (1, reps.size ()); @@ -200,7 +200,7 @@ TEST (rep_crawler, rep_remove) // genesis_rep should be found as principal representative after receiving a vote from it auto vote_genesis_rep = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - searching_node.rep_crawler.response (channel_genesis_rep, vote_genesis_rep, true); + searching_node.rep_crawler.force_process (vote_genesis_rep, channel_genesis_rep); ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 1); // Start a node for Rep2 and wait until it is connected @@ -212,7 +212,7 @@ TEST (rep_crawler, rep_remove) // Rep2 should be found as a principal representative after receiving a vote from it auto vote_rep2 = std::make_shared (keys_rep2.pub, keys_rep2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - ASSERT_FALSE (searching_node.rep_crawler.response (channel_rep2, vote_rep2, true)); + searching_node.rep_crawler.force_process (vote_rep2, channel_rep2); ASSERT_TIMELY_EQ (10s, searching_node.rep_crawler.representative_count (), 2); // When Rep2 is stopped, it should not be found as principal representative anymore diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 4bb58d41a1..ca99161876 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -305,13 +305,14 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons observers.endpoint.add ([this] (std::shared_ptr const & channel_a) { this->network.send_keepalive_self (channel_a); }); - observers.vote.add ([this] (std::shared_ptr vote_a, std::shared_ptr const & channel_a, nano::vote_code code_a) { - debug_assert (code_a != nano::vote_code::invalid); - auto active_in_rep_crawler (!this->rep_crawler.response (channel_a, vote_a)); + + observers.vote.add ([this] (std::shared_ptr vote, std::shared_ptr const & channel, nano::vote_code code) { + debug_assert (code != nano::vote_code::invalid); + bool active_in_rep_crawler = rep_crawler.process (vote, channel); if (active_in_rep_crawler) { // Representative is defined as online if replying to live votes or rep_crawler queries - this->online_reps.observe (vote_a->account); + online_reps.observe (vote->account); } }); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index c6014100e7..f1bb0cfc8c 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -314,21 +314,18 @@ bool nano::rep_crawler::is_pr (std::shared_ptr const & return false; } -// TODO: Remove force parameter -bool nano::rep_crawler::response (std::shared_ptr const & channel, std::shared_ptr const & vote, bool force) +bool nano::rep_crawler::process (std::shared_ptr const & vote, std::shared_ptr const & channel) { - bool error = true; nano::lock_guard lock{ mutex }; - for (auto const & hash : vote->hashes) + for (auto const & hash : vote->hashes) // TODO: This most likely should be a single hash vote { - if (force || queries.count (hash) != 0) + if (queries.count (hash) != 0) { responses.emplace_back (channel, vote); - error = false; - break; + return true; // Processed } } - return error; + return false; } nano::uint128_t nano::rep_crawler::total_weight () const @@ -407,7 +404,7 @@ void nano::rep_crawler::force_add_rep (const nano::account & account, const std: } // Only for tests -void nano::rep_crawler::force_response (const std::shared_ptr & channel, const std::shared_ptr & vote) +void nano::rep_crawler::force_process (const std::shared_ptr & vote, const std::shared_ptr & channel) { release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 666c618e34..c58449a409 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -45,6 +45,14 @@ class rep_crawler final void start (); void stop (); + /** + * Called when a non-replay vote on a block previously sent by query() is received. This indicates + * with high probability that the endpoint is a representative node. + * The force flag can be set to skip the active check in unit testing when we want to force a vote in the rep crawler. + * @return false if any vote passed the checks and was added to the response queue of the rep crawler + */ + bool process (std::shared_ptr const &, std::shared_ptr const &); + /** Remove block hash from list of active rep queries */ void remove (nano::block_hash const &); @@ -60,14 +68,6 @@ class rep_crawler final /** Query if a peer manages a principle representative */ bool is_pr (std::shared_ptr const &) const; - /** - * Called when a non-replay vote on a block previously sent by query() is received. This indicates - * with high probability that the endpoint is a representative node. - * The force flag can be set to skip the active check in unit testing when we want to force a vote in the rep crawler. - * @return false if any vote passed the checks and was added to the response queue of the rep crawler - */ - bool response (std::shared_ptr const &, std::shared_ptr const &, bool force = false); - /** Get total available weight from representatives */ nano::uint128_t total_weight () const; @@ -154,7 +154,7 @@ class rep_crawler final public: // Testing void force_add_rep (nano::account const & account, std::shared_ptr const & channel); - void force_response (std::shared_ptr const & channel, std::shared_ptr const & vote); + void force_process (std::shared_ptr const & vote, std::shared_ptr const & channel); void force_active_query (nano::block_hash const & hash); }; From c45d78f6adb2b6692021c8b2d5b317af6ef507c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 20 Feb 2024 11:58:06 +0100 Subject: [PATCH 115/190] Move remaining rep_crawler tests --- nano/core_test/node.cpp | 31 ------------------------------- nano/core_test/rep_crawler.cpp | 31 +++++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index defbadb8bd..15bcd4a87c 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3687,37 +3687,6 @@ TEST (node, deferred_dependent_elections) } } -// This test checks that if a block is in the recently_confirmed list then the repcrawler will not send a request for it. -// The behaviour of this test previously was the opposite, that the repcrawler eventually send out such a block and deleted the block -// from the recently confirmed list to try to make ammends for sending it, which is bad behaviour. -// In the long term, we should have a better way to check for reps and this test should become redundant -TEST (rep_crawler, recently_confirmed) -{ - nano::test::system system (1); - auto & node1 (*system.nodes[0]); - ASSERT_EQ (1, node1.ledger.cache.block_count); - auto const block = nano::dev::genesis; - node1.active.recently_confirmed.put (block->qualified_root (), block->hash ()); - auto & node2 (*system.add_node ()); - system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); - auto channel = node1.network.find_node_id (node2.get_node_id ()); - ASSERT_NE (nullptr, channel); - node1.rep_crawler.query (channel); // this query should be dropped due to the recently_confirmed entry - ASSERT_ALWAYS_EQ (0.5s, node1.rep_crawler.representative_count (), 0); -} - -// Votes from local channels should be ignored -TEST (rep_crawler, ignore_local) -{ - nano::test::system system; - nano::node_flags flags; - auto & node = *system.add_node (flags); - auto loopback = std::make_shared (node, node); - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - node.rep_crawler.force_process (vote, loopback); - ASSERT_ALWAYS_EQ (0.5s, node.rep_crawler.representative_count (), 0); -} - // Test that a node configured with `enable_pruning` and `max_pruning_age = 1s` will automatically // prune old confirmed blocks without explicitly saying `node.ledger_pruning` in the unit test TEST (node, pruning_automatic) diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 9b83ebc64c..a6f88e5796 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -238,4 +238,35 @@ TEST (rep_crawler, rep_connection_close) node2.stop (); // Remove representative with closed channel ASSERT_TIMELY_EQ (10s, node1.rep_crawler.representative_count (), 0); +} + +// This test checks that if a block is in the recently_confirmed list then the repcrawler will not send a request for it. +// The behaviour of this test previously was the opposite, that the repcrawler eventually send out such a block and deleted the block +// from the recently confirmed list to try to make ammends for sending it, which is bad behaviour. +// In the long term, we should have a better way to check for reps and this test should become redundant +TEST (rep_crawler, recently_confirmed) +{ + nano::test::system system (1); + auto & node1 (*system.nodes[0]); + ASSERT_EQ (1, node1.ledger.cache.block_count); + auto const block = nano::dev::genesis; + node1.active.recently_confirmed.put (block->qualified_root (), block->hash ()); + auto & node2 (*system.add_node ()); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); + auto channel = node1.network.find_node_id (node2.get_node_id ()); + ASSERT_NE (nullptr, channel); + node1.rep_crawler.query (channel); // this query should be dropped due to the recently_confirmed entry + ASSERT_ALWAYS_EQ (0.5s, node1.rep_crawler.representative_count (), 0); +} + +// Votes from local channels should be ignored +TEST (rep_crawler, ignore_local) +{ + nano::test::system system; + nano::node_flags flags; + auto & node = *system.add_node (flags); + auto loopback = std::make_shared (node, node); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); + node.rep_crawler.force_process (vote, loopback); + ASSERT_ALWAYS_EQ (0.5s, node.rep_crawler.representative_count (), 0); } \ No newline at end of file From 80c0b8b6d6f9d912b3b93b6b5165a6bf99a223f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 21 Feb 2024 14:57:29 +0100 Subject: [PATCH 116/190] Overhaul `rep_crawler` part 2 --- nano/core_test/node.cpp | 3 +- nano/lib/stats_enums.hpp | 7 + nano/node/network.cpp | 5 +- nano/node/network.hpp | 2 +- nano/node/node.cpp | 4 +- nano/node/nodeconfig.cpp | 13 +- nano/node/nodeconfig.hpp | 2 + nano/node/repcrawler.cpp | 272 ++++++++++++++++++++++++--------------- nano/node/repcrawler.hpp | 77 +++++++---- 9 files changed, 248 insertions(+), 137 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 15bcd4a87c..c38cc8f4cc 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1774,8 +1774,7 @@ TEST (node, online_reps_rep_crawler) node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (0, node1.online_reps.online ()); // After inserting to rep crawler - node1.rep_crawler.force_active_query (nano::dev::genesis->hash ()); - node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); + node1.rep_crawler.force_process (vote, std::make_shared (node1)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); } diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 496d9f63cd..fe15550b2f 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -331,6 +331,13 @@ enum class detail : uint8_t // rep_crawler channel_dead, + query_target_failed, + query_channel_busy, + query_sent, + rep_timeout, + query_timeout, + crawl_aggressive, + crawl_normal, _last // Must be the last enum }; diff --git a/nano/node/network.cpp b/nano/node/network.cpp index ca56cccc95..5d8613ecf5 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -219,10 +219,11 @@ void nano::network::flood_block_many (std::deque> b } } -void nano::network::send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a) +void nano::network::send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a) { + auto & [hash, root] = hash_root_a; // Confirmation request with hash + root - nano::confirm_req req (node.network_params.network, hash_root_a.first, hash_root_a.second); + nano::confirm_req req (node.network_params.network, hash, root); channel_a->send (req); } diff --git a/nano/node/network.hpp b/nano/node/network.hpp index 6ad08806c7..cd5b90e047 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -95,7 +95,7 @@ class network final void send_keepalive (std::shared_ptr const &); void send_keepalive_self (std::shared_ptr const &); void send_node_id_handshake (std::shared_ptr const &, std::optional const & cookie, std::optional const & respond_to); - void send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a); + void send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a); std::shared_ptr find_node_id (nano::account const &); std::shared_ptr find_channel (nano::endpoint const &); bool not_a_peer (nano::endpoint const &, bool); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index ca99161876..009158ac64 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -161,7 +161,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons tcp_listener{ std::make_shared (network.port, *this, config.tcp_incoming_connections_max) }, application_path (application_path_a), port_mapping (*this), - rep_crawler (*this), + rep_crawler (config.rep_crawler, *this), vote_processor (active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params), warmed_up (0), block_processor (*this, write_database_queue), @@ -305,7 +305,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons observers.endpoint.add ([this] (std::shared_ptr const & channel_a) { this->network.send_keepalive_self (channel_a); }); - + observers.vote.add ([this] (std::shared_ptr vote, std::shared_ptr const & channel, nano::vote_code code) { debug_assert (code != nano::vote_code::invalid); bool active_in_rep_crawler = rep_crawler.process (vote, channel); diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 175d78477b..f10f8c7c1e 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -31,7 +31,8 @@ nano::node_config::node_config (const std::optional & peering_port_a, hinted_scheduler{ network_params.network }, websocket_config{ network_params.network }, ipc_config{ network_params.network }, - external_address{ boost::asio::ip::address_v6{}.to_string () } + external_address{ boost::asio::ip::address_v6{}.to_string () }, + rep_crawler{ network_params.network } { if (peering_port == 0) { @@ -204,6 +205,10 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const vote_cache.serialize (vote_cache_l); toml.put_child ("vote_cache", vote_cache_l); + nano::tomlconfig rep_crawler_l; + rep_crawler.serialize (rep_crawler_l); + toml.put_child ("rep_crawler", rep_crawler_l); + return toml.get_error (); } @@ -273,6 +278,12 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) vote_cache.deserialize (config_l); } + if (toml.has_key ("rep_crawler")) + { + auto config_l = toml.get_required_child ("rep_crawler"); + rep_crawler.deserialize (config_l); + } + if (toml.has_key ("work_peers")) { work_peers.clear (); diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 8f7580534a..a7a4c0b185 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -127,6 +128,7 @@ class node_config /** Number of times per second to run backlog population batches. Number of accounts per single batch is `backlog_scan_batch_size / backlog_scan_frequency` */ unsigned backlog_scan_frequency{ 10 }; nano::vote_cache_config vote_cache; + nano::rep_crawler_config rep_crawler; public: std::string serialize_frontiers_confirmation (nano::frontiers_confirmation_mode) const; diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index f1bb0cfc8c..2b6fb041c3 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -3,9 +3,11 @@ #include -nano::rep_crawler::rep_crawler (nano::node & node_a) : +nano::rep_crawler::rep_crawler (nano::rep_crawler_config const & config_a, nano::node & node_a) : + config{ config_a }, node{ node_a }, stats{ node_a.stats }, + logger{ node_a.logger }, network_constants{ node_a.network_params.network }, active{ node_a.active } { @@ -46,18 +48,13 @@ void nano::rep_crawler::stop () } } -void nano::rep_crawler::remove (nano::block_hash const & hash) -{ - nano::lock_guard lock{ mutex }; - queries.erase (hash); -} - void nano::rep_crawler::validate_and_process (nano::unique_lock & lock) { debug_assert (!mutex.try_lock ()); debug_assert (lock.owns_lock ()); + debug_assert (!responses.empty ()); // Should be checked before calling this function - decltype (responses) responses_l; + decltype (responses) responses_l{ responses.capacity () }; responses_l.swap (responses); lock.unlock (); @@ -66,22 +63,24 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l // reps with less weight by setting rep_crawler_weight_minimum to a low value auto const minimum = std::min (node.minimum_principal_weight (), node.config.rep_crawler_weight_minimum.number ()); + // TODO: Is it really faster to repeatedly lock/unlock the mutex for each response? for (auto const & response : responses_l) { auto & vote = response.second; auto & channel = response.first; - debug_assert (channel != nullptr); + release_assert (vote != nullptr); + release_assert (channel != nullptr); if (channel->get_type () == nano::transport::transport_type::loopback) { - node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); + logger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); continue; } nano::uint128_t const rep_weight = node.ledger.weight (vote->account); if (rep_weight < minimum) { - node.logger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", + logger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", vote->account.to_account (), nano::util::to_str (rep_weight)); continue; @@ -96,22 +95,22 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l if (auto existing = reps.find (vote->account); existing != reps.end ()) { - reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (representative_entry & info) { - info.last_response = std::chrono::steady_clock::now (); + reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (rep_entry & rep) { + rep.last_response = std::chrono::steady_clock::now (); // Update if representative channel was changed - if (info.channel->get_endpoint () != channel->get_endpoint ()) + if (rep.channel->get_endpoint () != channel->get_endpoint ()) { - debug_assert (info.account == vote->account); + debug_assert (rep.account == vote->account); updated = true; - prev_channel = info.channel; - info.channel = channel; + prev_channel = rep.channel; + rep.channel = channel; } }); } else { - reps.emplace (representative_entry{ vote->account, channel }); + reps.emplace (rep_entry{ vote->account, channel }); inserted = true; } @@ -119,15 +118,25 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l if (inserted) { - node.logger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); + logger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); } if (updated) { - node.logger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); + logger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); } } } +std::chrono::milliseconds nano::rep_crawler::query_interval (bool sufficient_weight) const +{ + return sufficient_weight ? network_constants.rep_crawler_normal_interval : network_constants.rep_crawler_warmup_interval; +} + +bool nano::rep_crawler::query_predicate (bool sufficient_weight) const +{ + return nano::elapsed (last_query, query_interval (sufficient_weight)); +} + void nano::rep_crawler::run () { nano::unique_lock lock{ mutex }; @@ -147,7 +156,10 @@ void nano::rep_crawler::run () lock.lock (); - condition.wait_for (lock, sufficient_weight ? network_constants.rep_crawler_normal_interval : network_constants.rep_crawler_warmup_interval); + condition.wait_for (lock, query_interval (sufficient_weight), [this, sufficient_weight] { + return stopped || query_predicate (sufficient_weight) || !responses.empty (); + }); + if (stopped) { return; @@ -155,15 +167,28 @@ void nano::rep_crawler::run () stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::loop); + if (!responses.empty ()) + { + validate_and_process (lock); + debug_assert (!lock.owns_lock ()); + lock.lock (); + } + cleanup (); - validate_and_process (lock); - debug_assert (!lock.owns_lock ()); + if (query_predicate (sufficient_weight)) + { + last_query = std::chrono::steady_clock::now (); - auto targets = get_crawl_targets (current_total_weight); - query (targets); + lock.unlock (); - lock.lock (); + auto targets = prepare_crawl_targets (sufficient_weight); + query (targets); + + lock.lock (); + } + + debug_assert (lock.owns_lock ()); } } @@ -171,26 +196,51 @@ void nano::rep_crawler::cleanup () { debug_assert (!mutex.try_lock ()); - erase_if (reps, [this] (representative_entry const & rep) { + // Evict reps with dead channels + erase_if (reps, [this] (rep_entry const & rep) { if (!rep.channel->alive ()) { + logger.debug (nano::log::type::repcrawler, "Evicting representative {} with dead channel at {}", rep.account.to_account (), rep.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::channel_dead); return true; // Erase } return false; }); + + // Evict reps that haven't responded in a while + erase_if (reps, [this] (rep_entry const & rep) { + if (nano::elapsed (rep.last_response, config.rep_timeout)) + { + logger.debug (nano::log::type::repcrawler, "Evicting unresponsive representative {} at {}", rep.account.to_account (), rep.channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::rep_timeout); + return true; // Erase + } + return false; + }); + + // Evict queries that haven't been responded to in a while + erase_if (queries, [this] (query_entry const & query) { + if (nano::elapsed (query.time, config.query_timeout)) + { + logger.debug (nano::log::type::repcrawler, "Evicting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_timeout); + return true; // Erase + } + return false; + }); } -std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t current_total_weight) const +std::vector> nano::rep_crawler::prepare_crawl_targets (bool sufficient_weight) const { // TODO: Make these values configurable constexpr std::size_t conservative_count = 10; constexpr std::size_t aggressive_count = 40; // Crawl more aggressively if we lack sufficient total peer weight. - bool sufficient_weight = current_total_weight > node.online_reps.delta (); auto required_peer_count = sufficient_weight ? conservative_count : aggressive_count; + stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); + // Add random peers. We do this even if we have enough weight, in order to pick up reps // that didn't respond when first observed. If the current total weight isn't sufficient, this // will be more aggressive. When the node first starts, the rep container is empty and all @@ -202,7 +252,7 @@ std::vector> nano::rep_crawler::get_cr return { random_peers.begin (), random_peers.end () }; } -std::optional> nano::rep_crawler::prepare_query_target () +auto nano::rep_crawler::prepare_query_target () -> std::optional { constexpr int max_attempts = 4; @@ -232,23 +282,31 @@ std::optional> nano::rep_crawler:: { nano::lock_guard lock{ mutex }; - for (auto i = 0; queries.count (hash_root->first) != 0 && i < 4; ++i) + for (auto i = 0; queries.get ().count (hash_root->first) != 0 && i < max_attempts; ++i) { hash_root = node.ledger.hash_root_random (transaction); } } - if (!hash_root) - { - return std::nullopt; - } + return hash_root; +} + +void nano::rep_crawler::track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel) +{ + debug_assert (!mutex.try_lock ()); + + debug_assert (queries.count (channel) == 0); // Only a single query should be active per channel + queries.emplace (query_entry{ hash_root.first, channel }); + // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) + auto & index = reps.get (); + auto [begin, end] = index.equal_range (channel); + for (auto it = begin; it != end; ++it) { - nano::lock_guard lock{ mutex }; - queries.insert (hash_root->first); + index.modify (it, [] (rep_entry & info) { + info.last_request = std::chrono::steady_clock::now (); + }); } - - return hash_root; } void nano::rep_crawler::query (std::vector> const & target_channels) @@ -256,27 +314,31 @@ void nano::rep_crawler::query (std::vector lock{ mutex }; + for (const auto & channel : target_channels) { debug_assert (channel != nullptr); - on_rep_request (channel); - node.network.send_confirm_req (channel, hash_root); - } - // TODO: Use a thread+timeout instead of a timer - // A representative must respond with a vote within the deadline - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root.first] () { - if (auto node_l = node_w.lock ()) + // Only a single query should be active per channel + if (queries.find (channel) == queries.end ()) { - auto target_finished_processed (node_l->vote_processor.total_processed + node_l->vote_processor.size ()); - node_l->rep_crawler.throttled_remove (hash, target_finished_processed); + track_rep_request (hash_root, channel); + node.network.send_confirm_req (channel, hash_root); + + logger.debug (nano::log::type::repcrawler, "Sending query for block {} to {}", hash_root.first.to_string (), channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_sent); } - }); + else + { + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_channel_busy); + } + } } void nano::rep_crawler::query (std::shared_ptr const & target_channel) @@ -284,32 +346,13 @@ void nano::rep_crawler::query (std::shared_ptr const & query (std::vector{ target_channel }); } -// TODO: Use a thread+timeout instead of a timer -void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint64_t const target_finished_processed) -{ - if (node.vote_processor.total_processed >= target_finished_processed) - { - remove (hash_a); - } - else - { - std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash_a, target_finished_processed] () { - if (auto node_l = node_w.lock ()) - { - node_l->rep_crawler.throttled_remove (hash_a, target_finished_processed); - } - }); - } -} - bool nano::rep_crawler::is_pr (std::shared_ptr const & channel) const { nano::lock_guard lock{ mutex }; auto existing = reps.get ().find (channel); if (existing != reps.get ().end ()) { - return node.ledger.weight (existing->account) > node.minimum_principal_weight (); + return node.ledger.weight (existing->account) >= node.minimum_principal_weight (); } return false; } @@ -317,12 +360,24 @@ bool nano::rep_crawler::is_pr (std::shared_ptr const & bool nano::rep_crawler::process (std::shared_ptr const & vote, std::shared_ptr const & channel) { nano::lock_guard lock{ mutex }; - for (auto const & hash : vote->hashes) // TODO: This most likely should be a single hash vote + if (auto info = queries.find (channel); info != queries.end ()) { - if (queries.count (hash) != 0) + // TODO: This linear search could be slow, especially with large votes. + auto const target_hash = info->hash; + bool found = std::any_of (vote->hashes.begin (), vote->hashes.end (), [&target_hash] (nano::block_hash const & hash) { + return hash == target_hash; + }); + + if (found) { - responses.emplace_back (channel, vote); - return true; // Processed + logger.debug (nano::log::type::repcrawler, "Processing response for block {} from {}", target_hash.to_string (), channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::response); + // TODO: Track query response time + + responses.push_back ({ channel, vote }); + + queries.erase (info); + return true; } } return false; @@ -342,30 +397,13 @@ nano::uint128_t nano::rep_crawler::total_weight () const return result; } -void nano::rep_crawler::on_rep_request (std::shared_ptr const & channel) -{ - nano::lock_guard lock{ mutex }; - if (channel->get_tcp_endpoint ().address () != boost::asio::ip::address_v6::any ()) - { - // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) - auto & index = reps.get (); - auto [begin, end] = index.equal_range (channel); - for (auto it = begin; it != end; ++it) - { - index.modify (it, [] (representative_entry & info) { - info.last_request = std::chrono::steady_clock::now (); - }); - } - } -} - std::vector nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) { auto const version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); nano::lock_guard lock{ mutex }; - std::multimap> ordered; + std::multimap> ordered; for (const auto & i : reps.get ()) { auto weight = node.ledger.weight (i.account); @@ -400,7 +438,7 @@ void nano::rep_crawler::force_add_rep (const nano::account & account, const std: { release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; - reps.emplace (representative_entry{ account, channel }); + reps.emplace (rep_entry{ account, channel }); } // Only for tests @@ -408,18 +446,7 @@ void nano::rep_crawler::force_process (const std::shared_ptr & vote, { release_assert (node.network_params.network.is_dev_network ()); nano::lock_guard lock{ mutex }; - for (auto const & hash : vote->hashes) - { - responses.emplace_back (channel, vote); - } -} - -// Only for tests -void nano::rep_crawler::force_active_query (const nano::block_hash & hash) -{ - release_assert (node.network_params.network.is_dev_network ()); - nano::lock_guard lock{ mutex }; - queries.insert (hash); + responses.push_back ({ channel, vote }); } std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) @@ -434,4 +461,39 @@ std::unique_ptr nano::collect_container_info (re auto composite = std::make_unique (name); composite->add_component (std::make_unique (container_info{ "queries", count, sizeof_element })); return composite; +} + +/* + * rep_crawler_config + */ + +nano::rep_crawler_config::rep_crawler_config (nano::network_constants const & network_constants) +{ + if (network_constants.is_dev_network ()) + { + rep_timeout = std::chrono::milliseconds{ 1000 * 3 }; + query_timeout = std::chrono::milliseconds{ 1000 }; + } +} + +nano::error nano::rep_crawler_config::serialize (nano::tomlconfig & toml) const +{ + // TODO: Descriptions + toml.put ("rep_timeout", rep_timeout.count ()); + toml.put ("query_timeout", query_timeout.count ()); + + return toml.get_error (); +} + +nano::error nano::rep_crawler_config::deserialize (nano::tomlconfig & toml) +{ + auto rep_timeout_l = rep_timeout.count (); + toml.get ("rep_timeout", rep_timeout_l); + rep_timeout = std::chrono::milliseconds{ rep_timeout_l }; + + auto query_timeout_l = query_timeout.count (); + toml.get ("query_timeout", query_timeout_l); + query_timeout = std::chrono::milliseconds{ query_timeout_l }; + + return toml.get_error (); } \ No newline at end of file diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index c58449a409..c3ab336264 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include @@ -30,6 +31,19 @@ struct representative std::shared_ptr channel; }; +class rep_crawler_config final +{ +public: + explicit rep_crawler_config (nano::network_constants const &); + + nano::error deserialize (nano::tomlconfig & toml); + nano::error serialize (nano::tomlconfig & toml) const; + +public: + std::chrono::milliseconds query_timeout{ 1000 * 30 }; + std::chrono::milliseconds rep_timeout{ 1000 * 60 * 5 }; +}; + /** * Crawls the network for representatives. Queries are performed by requesting confirmation of a * random block and observing the corresponding vote. @@ -39,7 +53,7 @@ class rep_crawler final friend std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); public: - explicit rep_crawler (nano::node &); + rep_crawler (rep_crawler_config const &, nano::node &); ~rep_crawler (); void start (); @@ -53,12 +67,6 @@ class rep_crawler final */ bool process (std::shared_ptr const &, std::shared_ptr const &); - /** Remove block hash from list of active rep queries */ - void remove (nano::block_hash const &); - - /** Remove block hash from with delay depending on vote processor size */ - void throttled_remove (nano::block_hash const &, uint64_t target_finished_processed); - /** Attempt to determine if the peer manages one or more representative accounts */ void query (std::vector> const & target_channels); @@ -81,8 +89,10 @@ class rep_crawler final std::size_t representative_count (); private: // Dependencies + rep_crawler_config const & config; nano::node & node; nano::stats & stats; + nano::logger & logger; nano::network_constants & network_constants; nano::active_transactions & active; @@ -90,22 +100,23 @@ class rep_crawler final void run (); void cleanup (); void validate_and_process (nano::unique_lock &); + bool query_predicate (bool sufficient_weight) const; + std::chrono::milliseconds query_interval (bool sufficient_weight) const; - /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ - std::vector> get_crawl_targets (nano::uint128_t current_total_weight) const; - - /** When a rep request is made, this is called to update the last-request timestamp. */ - void on_rep_request (std::shared_ptr const & channel_a); + using hash_root_t = std::pair; - std::optional> prepare_query_target (); + /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ + std::vector> prepare_crawl_targets (bool sufficient_weight) const; + std::optional prepare_query_target (); + void track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel_a); private: /** * A representative picked up during repcrawl. */ - struct representative_entry + struct rep_entry { - representative_entry (nano::account account_a, std::shared_ptr const & channel_a) : + rep_entry (nano::account account_a, std::shared_ptr const & channel_a) : account{ account_a }, channel{ channel_a } { @@ -116,7 +127,7 @@ class rep_crawler final std::shared_ptr channel; std::chrono::steady_clock::time_point last_request{}; - std::chrono::steady_clock::time_point last_response{}; + std::chrono::steady_clock::time_point last_response{ std::chrono::steady_clock::now () }; nano::account get_account () const { @@ -124,30 +135,49 @@ class rep_crawler final } }; + struct query_entry + { + nano::block_hash hash; + std::shared_ptr channel; + std::chrono::steady_clock::time_point time{ std::chrono::steady_clock::now () }; + }; + // clang-format off + class tag_hash {}; class tag_account {}; class tag_channel {}; class tag_sequenced {}; - using ordered_reps = boost::multi_index_container, - mi::const_mem_fun>, + mi::const_mem_fun>, mi::sequenced>, mi::hashed_non_unique, - mi::member, &representative_entry::channel>> + mi::member, &rep_entry::channel>> + >>; + + using ordered_queries = boost::multi_index_container, + mi::member, &query_entry::channel>>, + mi::sequenced>, + mi::hashed_non_unique, + mi::member> >>; // clang-format on ordered_reps reps; + ordered_queries queries; private: - /** We have solicited votes for these random blocks */ - std::unordered_set queries; + static size_t constexpr max_responses{ 1024 * 4 }; + using response_t = std::pair, std::shared_ptr>; + boost::circular_buffer responses{ max_responses }; - std::deque, std::shared_ptr>> responses; + std::chrono::steady_clock::time_point last_query{}; - bool stopped{ false }; + std::atomic stopped{ false }; nano::condition_variable condition; mutable nano::mutex mutex; std::thread thread; @@ -155,7 +185,6 @@ class rep_crawler final public: // Testing void force_add_rep (nano::account const & account, std::shared_ptr const & channel); void force_process (std::shared_ptr const & vote, std::shared_ptr const & channel); - void force_active_query (nano::block_hash const & hash); }; std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); From 60f19010c02de76ffdb96a0724715d3b26d83d4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Fri, 23 Feb 2024 12:57:01 +0100 Subject: [PATCH 117/190] Fix tests --- nano/core_test/node.cpp | 4 +++- nano/core_test/rep_crawler.cpp | 6 +++--- nano/node/repcrawler.cpp | 8 ++++++++ nano/node/repcrawler.hpp | 1 + 4 files changed, 15 insertions(+), 4 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index c38cc8f4cc..53b3872b3e 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1774,7 +1774,9 @@ TEST (node, online_reps_rep_crawler) node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); ASSERT_EQ (0, node1.online_reps.online ()); // After inserting to rep crawler - node1.rep_crawler.force_process (vote, std::make_shared (node1)); + auto channel = std::make_shared (node1); + node1.rep_crawler.force_query (nano::dev::genesis->hash (), channel); + node1.vote_processor.vote_blocking (vote, channel); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); } diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index a6f88e5796..85f4ba1811 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -94,9 +94,9 @@ TEST (rep_crawler, rep_weight) auto vote0 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); - ASSERT_TRUE (node.rep_crawler.process (vote0, channel1)); - ASSERT_TRUE (node.rep_crawler.process (vote1, channel2)); - ASSERT_TRUE (node.rep_crawler.process (vote2, channel3)); + node.rep_crawler.force_process (vote0, channel1); + node.rep_crawler.force_process (vote1, channel2); + node.rep_crawler.force_process (vote2, channel3); ASSERT_TIMELY_EQ (5s, node.rep_crawler.representative_count (), 2); // Make sure we get the rep with the most weight first auto reps = node.rep_crawler.representatives (1); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 2b6fb041c3..f47cddb961 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -449,6 +449,14 @@ void nano::rep_crawler::force_process (const std::shared_ptr & vote, responses.push_back ({ channel, vote }); } +// Only for tests +void nano::rep_crawler::force_query (const nano::block_hash & hash, const std::shared_ptr & channel) +{ + release_assert (node.network_params.network.is_dev_network ()); + nano::lock_guard lock{ mutex }; + queries.emplace (query_entry{ hash, channel }); +} + std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) { std::size_t count; diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index c3ab336264..3a8ec3ab3e 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -185,6 +185,7 @@ class rep_crawler final public: // Testing void force_add_rep (nano::account const & account, std::shared_ptr const & channel); void force_process (std::shared_ptr const & vote, std::shared_ptr const & channel); + void force_query (nano::block_hash const & hash, std::shared_ptr const & channel); }; std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); From 331ea3cc2c516d02d8b70b1568ab9e3420fefd5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 24 Feb 2024 15:20:07 +0100 Subject: [PATCH 118/190] Cleanup --- nano/node/repcrawler.cpp | 23 ++++++++++++----------- nano/node/repcrawler.hpp | 11 +++++++---- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index f47cddb961..c5972bd72f 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -1,7 +1,7 @@ #include #include -#include +#include nano::rep_crawler::rep_crawler (nano::rep_crawler_config const & config_a, nano::node & node_a) : config{ config_a }, @@ -48,6 +48,7 @@ void nano::rep_crawler::stop () } } +// Exits with the lock unlocked void nano::rep_crawler::validate_and_process (nano::unique_lock & lock) { debug_assert (!mutex.try_lock ()); @@ -397,33 +398,33 @@ nano::uint128_t nano::rep_crawler::total_weight () const return result; } -std::vector nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) +std::vector nano::rep_crawler::representatives (std::size_t count, nano::uint128_t const minimum_weight, std::optional const & minimum_protocol_version) { - auto const version_min = opt_version_min_a.value_or (node.network_params.network.protocol_version_min); + auto const version_min = minimum_protocol_version.value_or (node.network_params.network.protocol_version_min); nano::lock_guard lock{ mutex }; std::multimap> ordered; - for (const auto & i : reps.get ()) + for (const auto & rep : reps.get ()) { - auto weight = node.ledger.weight (i.account); - if (weight > weight_a && i.channel->get_network_version () >= version_min) + auto weight = node.ledger.weight (rep.account); + if (weight >= minimum_weight && rep.channel->get_network_version () >= version_min) { - ordered.insert ({ nano::amount{ weight }, i }); + ordered.insert ({ nano::amount{ weight }, rep }); } } std::vector result; - for (auto i = ordered.begin (), n = ordered.end (); i != n && result.size () < count_a; ++i) + for (auto const & [weight, rep] : ordered | std::views::take (count)) { - result.push_back ({ i->second.account, i->second.channel }); + result.push_back ({ rep.account, rep.channel }); } return result; } -std::vector nano::rep_crawler::principal_representatives (std::size_t count_a, boost::optional const & opt_version_min_a) +std::vector nano::rep_crawler::principal_representatives (std::size_t count, std::optional const & minimum_protocol_version) { - return representatives (count_a, node.minimum_principal_weight (), opt_version_min_a); + return representatives (count, node.minimum_principal_weight (), minimum_protocol_version); } /** Total number of representatives */ diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 3a8ec3ab3e..48c8bda3a0 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -79,13 +79,16 @@ class rep_crawler final /** Get total available weight from representatives */ nano::uint128_t total_weight () const; - /** Request a list of the top \p count_a known representatives in descending order of weight, with at least \p weight_a voting weight, and optionally with a minimum version \p opt_version_min_a */ - std::vector representatives (std::size_t count_a = std::numeric_limits::max (), nano::uint128_t weight_a = 0, boost::optional const & opt_version_min_a = boost::none); + /** Request a list of the top \p count known representatives in descending order of weight, with at least \p weight_a voting weight, and optionally with a minimum version \p minimum_protocol_version + */ + std::vector representatives (std::size_t count = std::numeric_limits::max (), nano::uint128_t minimum_weight = 0, std::optional const & minimum_protocol_version = {}); - /** Request a list of the top \p count_a known principal representatives in descending order of weight, optionally with a minimum version \p opt_version_min_a */ - std::vector principal_representatives (std::size_t count_a = std::numeric_limits::max (), boost::optional const & opt_version_min_a = boost::none); + /** Request a list of the top \p count known principal representatives in descending order of weight, optionally with a minimum version \p minimum_protocol_version + */ + std::vector principal_representatives (std::size_t count = std::numeric_limits::max (), std::optional const & minimum_protocol_version = {}); /** Total number of representatives */ + std::size_t representative_count (); private: // Dependencies From 5c93dddac9d4bbd18edf10510a2da356f1e14166 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 24 Feb 2024 15:54:24 +0100 Subject: [PATCH 119/190] Uniform rep crawler log enum naming --- nano/lib/logging_enums.hpp | 2 +- nano/node/repcrawler.cpp | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index 33d40a3ce1..41668e674e 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -63,7 +63,7 @@ enum class type epoch_upgrader, opencl_work, upnp, - repcrawler, + rep_crawler, lmdb, rocksdb, txn_tracker, diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index c5972bd72f..c5b6dbb700 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -74,14 +74,14 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l if (channel->get_type () == nano::transport::transport_type::loopback) { - logger.debug (nano::log::type::repcrawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Ignoring vote from loopback channel: {}", channel->to_string ()); continue; } nano::uint128_t const rep_weight = node.ledger.weight (vote->account); if (rep_weight < minimum) { - logger.debug (nano::log::type::repcrawler, "Ignoring vote from account {} with too little voting weight: {}", + logger.debug (nano::log::type::rep_crawler, "Ignoring vote from account {} with too little voting weight: {}", vote->account.to_account (), nano::util::to_str (rep_weight)); continue; @@ -119,11 +119,11 @@ void nano::rep_crawler::validate_and_process (nano::unique_lock & l if (inserted) { - logger.info (nano::log::type::repcrawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); + logger.info (nano::log::type::rep_crawler, "Found representative {} at {}", vote->account.to_account (), channel->to_string ()); } if (updated) { - logger.warn (nano::log::type::repcrawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); + logger.warn (nano::log::type::rep_crawler, "Updated representative {} at {} (was at: {})", vote->account.to_account (), channel->to_string (), prev_channel->to_string ()); } } } @@ -201,7 +201,7 @@ void nano::rep_crawler::cleanup () erase_if (reps, [this] (rep_entry const & rep) { if (!rep.channel->alive ()) { - logger.debug (nano::log::type::repcrawler, "Evicting representative {} with dead channel at {}", rep.account.to_account (), rep.channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Evicting representative {} with dead channel at {}", rep.account.to_account (), rep.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::channel_dead); return true; // Erase } @@ -212,7 +212,7 @@ void nano::rep_crawler::cleanup () erase_if (reps, [this] (rep_entry const & rep) { if (nano::elapsed (rep.last_response, config.rep_timeout)) { - logger.debug (nano::log::type::repcrawler, "Evicting unresponsive representative {} at {}", rep.account.to_account (), rep.channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Evicting unresponsive representative {} at {}", rep.account.to_account (), rep.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::rep_timeout); return true; // Erase } @@ -223,7 +223,7 @@ void nano::rep_crawler::cleanup () erase_if (queries, [this] (query_entry const & query) { if (nano::elapsed (query.time, config.query_timeout)) { - logger.debug (nano::log::type::repcrawler, "Evicting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Evicting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_timeout); return true; // Erase } @@ -332,7 +332,7 @@ void nano::rep_crawler::query (std::vectorto_string ()); + logger.debug (nano::log::type::rep_crawler, "Sending query for block {} to {}", hash_root.first.to_string (), channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_sent); } else @@ -371,7 +371,7 @@ bool nano::rep_crawler::process (std::shared_ptr const & vote, std:: if (found) { - logger.debug (nano::log::type::repcrawler, "Processing response for block {} from {}", target_hash.to_string (), channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Processing response for block {} from {}", target_hash.to_string (), channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::response); // TODO: Track query response time From 603379e4877b834482dc391e45f73d3c4e0718d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 24 Feb 2024 15:57:19 +0100 Subject: [PATCH 120/190] Notify condition after successful response --- nano/node/repcrawler.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index c5b6dbb700..5bb35e0dc6 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -376,8 +376,9 @@ bool nano::rep_crawler::process (std::shared_ptr const & vote, std:: // TODO: Track query response time responses.push_back ({ channel, vote }); - queries.erase (info); + + condition.notify_all (); return true; } } From 202d6ce7cb85c5f2a6d43ab8628103683f282260 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 25 Feb 2024 13:05:52 +0100 Subject: [PATCH 121/190] Simplify `keepalive_preconfigured ()` --- nano/node/node.cpp | 6 +++--- nano/node/node.hpp | 2 +- nano/node/repcrawler.cpp | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 009158ac64..53a1a1726c 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -689,14 +689,14 @@ void nano::node::stop () // work pool is not stopped on purpose due to testing setup } -void nano::node::keepalive_preconfigured (std::vector const & peers_a) +void nano::node::keepalive_preconfigured () { - for (auto i (peers_a.begin ()), n (peers_a.end ()); i != n; ++i) + for (auto const & peer : config.preconfigured_peers) { // can't use `network.port` here because preconfigured peers are referenced // just by their address, so we rely on them listening on the default port // - keepalive (*i, network_params.network.default_node_port); + keepalive (peer, network_params.network.default_node_port); } } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index e3daaae82a..f87dc3096d 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -86,7 +86,7 @@ class node final : public std::enable_shared_from_this void process_active (std::shared_ptr const &); std::optional process_local (std::shared_ptr const &); void process_local_async (std::shared_ptr const &); - void keepalive_preconfigured (std::vector const &); + void keepalive_preconfigured (); std::shared_ptr block (nano::block_hash const &); std::pair balance_pending (nano::account const &, bool only_confirmed); nano::uint128_t weight (nano::account const &); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 5bb35e0dc6..2dded73005 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -152,7 +152,7 @@ void nano::rep_crawler::run () if (!sufficient_weight) { stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::keepalive); - node.keepalive_preconfigured (node.config.preconfigured_peers); + node.keepalive_preconfigured (); } lock.lock (); From beb4c5beb4851c26749f53b6a883335ab668a570 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 25 Feb 2024 13:03:05 +0100 Subject: [PATCH 122/190] Allow multiple queries per channel during warmup --- nano/lib/stats_enums.hpp | 1 + nano/node/repcrawler.cpp | 58 ++++++++++++++++++++++++---------------- nano/node/repcrawler.hpp | 4 +-- 3 files changed, 38 insertions(+), 25 deletions(-) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index fe15550b2f..edad231fd5 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -334,6 +334,7 @@ enum class detail : uint8_t query_target_failed, query_channel_busy, query_sent, + query_duplicate, rep_timeout, query_timeout, crawl_aggressive, diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 2dded73005..746de3040c 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -181,11 +181,10 @@ void nano::rep_crawler::run () { last_query = std::chrono::steady_clock::now (); - lock.unlock (); - auto targets = prepare_crawl_targets (sufficient_weight); - query (targets); + lock.unlock (); + query (targets); lock.lock (); } @@ -233,23 +232,27 @@ void nano::rep_crawler::cleanup () std::vector> nano::rep_crawler::prepare_crawl_targets (bool sufficient_weight) const { + debug_assert (!mutex.try_lock ()); + // TODO: Make these values configurable constexpr std::size_t conservative_count = 10; constexpr std::size_t aggressive_count = 40; + constexpr std::size_t conservative_max_attempts = 1; + constexpr std::size_t aggressive_max_attempts = 8; + + stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); // Crawl more aggressively if we lack sufficient total peer weight. - auto required_peer_count = sufficient_weight ? conservative_count : aggressive_count; + auto const required_peer_count = sufficient_weight ? conservative_count : aggressive_count; - stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); + auto random_peers = node.network.random_set (required_peer_count, 0, /* Include channels with ephemeral remote ports */ true); - // Add random peers. We do this even if we have enough weight, in order to pick up reps - // that didn't respond when first observed. If the current total weight isn't sufficient, this - // will be more aggressive. When the node first starts, the rep container is empty and all - // endpoints will originate from random peers. - required_peer_count += required_peer_count / 2; + // Avoid querying the same peer multiple times when rep crawler is warmed up + auto const max_attempts = sufficient_weight ? conservative_max_attempts : aggressive_max_attempts; + erase_if (random_peers, [this, max_attempts] (std::shared_ptr const & channel) { + return queries.get ().count (channel) >= max_attempts; + }); - // The rest of the endpoints are picked randomly - auto random_peers = node.network.random_set (required_peer_count, 0, true); // Include channels with ephemeral remote ports return { random_peers.begin (), random_peers.end () }; } @@ -292,12 +295,15 @@ auto nano::rep_crawler::prepare_query_target () -> std::optional return hash_root; } -void nano::rep_crawler::track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel) +bool nano::rep_crawler::track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel) { debug_assert (!mutex.try_lock ()); - debug_assert (queries.count (channel) == 0); // Only a single query should be active per channel - queries.emplace (query_entry{ hash_root.first, channel }); + auto [_, inserted] = queries.emplace (query_entry{ hash_root.first, channel }); + if (!inserted) + { + return false; // Duplicate, not tracked + } // Find and update the timestamp on all reps available on the endpoint (a single host may have multiple reps) auto & index = reps.get (); @@ -308,6 +314,8 @@ void nano::rep_crawler::track_rep_request (hash_root_t hash_root, std::shared_pt info.last_request = std::chrono::steady_clock::now (); }); } + + return true; } void nano::rep_crawler::query (std::vector> const & target_channels) @@ -315,6 +323,7 @@ void nano::rep_crawler::query (std::vectorto_string ()); @@ -337,7 +345,8 @@ void nano::rep_crawler::query (std::vectorto_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_duplicate); } } } @@ -361,10 +370,13 @@ bool nano::rep_crawler::is_pr (std::shared_ptr const & bool nano::rep_crawler::process (std::shared_ptr const & vote, std::shared_ptr const & channel) { nano::lock_guard lock{ mutex }; - if (auto info = queries.find (channel); info != queries.end ()) + + auto & index = queries.get (); + auto [begin, end] = index.equal_range (channel); + for (auto it = begin; it != end; ++it) { // TODO: This linear search could be slow, especially with large votes. - auto const target_hash = info->hash; + auto const target_hash = it->hash; bool found = std::any_of (vote->hashes.begin (), vote->hashes.end (), [&target_hash] (nano::block_hash const & hash) { return hash == target_hash; }); @@ -376,10 +388,10 @@ bool nano::rep_crawler::process (std::shared_ptr const & vote, std:: // TODO: Track query response time responses.push_back ({ channel, vote }); - queries.erase (info); + queries.erase (it); condition.notify_all (); - return true; + return true; // Found and processed } } return false; diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 48c8bda3a0..0b20530475 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -111,7 +111,7 @@ class rep_crawler final /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ std::vector> prepare_crawl_targets (bool sufficient_weight) const; std::optional prepare_query_target (); - void track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel_a); + bool track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel_a); private: /** @@ -162,7 +162,7 @@ class rep_crawler final using ordered_queries = boost::multi_index_container, + mi::hashed_non_unique, mi::member, &query_entry::channel>>, mi::sequenced>, mi::hashed_non_unique, From 638b18e47f1697e509eb8dd2d7e725edcfee487b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 25 Feb 2024 15:07:38 +0100 Subject: [PATCH 123/190] Improve `collect_container_info ()` --- nano/node/node.cpp | 2 +- nano/node/repcrawler.cpp | 26 +++++++++++--------------- nano/node/repcrawler.hpp | 9 +++------ 3 files changed, 15 insertions(+), 22 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 53a1a1726c..9a34388c5b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -523,7 +523,7 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (collect_container_info (node.observers, "observers")); composite->add_component (collect_container_info (node.wallets, "wallets")); composite->add_component (collect_container_info (node.vote_processor, "vote_processor")); - composite->add_component (collect_container_info (node.rep_crawler, "rep_crawler")); + composite->add_component (node.rep_crawler.collect_container_info ("rep_crawler")); composite->add_component (node.block_processor.collect_container_info ("block_processor")); composite->add_component (collect_container_info (node.online_reps, "online_reps")); composite->add_component (collect_container_info (node.history, "history")); diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 746de3040c..fbb9eaf1e8 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -440,13 +440,23 @@ std::vector nano::rep_crawler::principal_representatives ( return representatives (count, node.minimum_principal_weight (), minimum_protocol_version); } -/** Total number of representatives */ std::size_t nano::rep_crawler::representative_count () { nano::lock_guard lock{ mutex }; return reps.size (); } +std::unique_ptr nano::rep_crawler::collect_container_info (const std::string & name) +{ + nano::lock_guard guard{ mutex }; + + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (container_info{ "reps", reps.size (), sizeof (decltype (reps)::value_type) })); + composite->add_component (std::make_unique (container_info{ "queries", queries.size (), sizeof (decltype (queries)::value_type) })); + composite->add_component (std::make_unique (container_info{ "responses", responses.size (), sizeof (decltype (responses)::value_type) })); + return composite; +} + // Only for tests void nano::rep_crawler::force_add_rep (const nano::account & account, const std::shared_ptr & channel) { @@ -471,20 +481,6 @@ void nano::rep_crawler::force_query (const nano::block_hash & hash, const std::s queries.emplace (query_entry{ hash, channel }); } -std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) -{ - std::size_t count; - { - nano::lock_guard guard{ rep_crawler.mutex }; - count = rep_crawler.queries.size (); - } - - auto const sizeof_element = sizeof (decltype (rep_crawler.queries)::value_type); - auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "queries", count, sizeof_element })); - return composite; -} - /* * rep_crawler_config */ diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 0b20530475..c7dab61a24 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -50,8 +50,6 @@ class rep_crawler_config final */ class rep_crawler final { - friend std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); - public: rep_crawler (rep_crawler_config const &, nano::node &); ~rep_crawler (); @@ -88,9 +86,10 @@ class rep_crawler final std::vector principal_representatives (std::size_t count = std::numeric_limits::max (), std::optional const & minimum_protocol_version = {}); /** Total number of representatives */ - std::size_t representative_count (); + std::unique_ptr collect_container_info (std::string const & name); + private: // Dependencies rep_crawler_config const & config; nano::node & node; @@ -111,7 +110,7 @@ class rep_crawler final /** Returns a list of endpoints to crawl. The total weight is passed in to avoid computing it twice. */ std::vector> prepare_crawl_targets (bool sufficient_weight) const; std::optional prepare_query_target (); - bool track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel_a); + bool track_rep_request (hash_root_t hash_root, std::shared_ptr const & channel); private: /** @@ -190,6 +189,4 @@ class rep_crawler final void force_process (std::shared_ptr const & vote, std::shared_ptr const & channel); void force_query (nano::block_hash const & hash, std::shared_ptr const & channel); }; - -std::unique_ptr collect_container_info (rep_crawler & rep_crawler, std::string const & name); } From 701d8214b3d0c43e3fb17eb970affa7d2366a36a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 26 Feb 2024 14:13:40 +0100 Subject: [PATCH 124/190] No limiter drop --- nano/node/repcrawler.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index fbb9eaf1e8..d41916fdae 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -338,10 +338,21 @@ void nano::rep_crawler::query (std::vectorto_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_sent); + + auto const & [hash, root] = hash_root; + nano::confirm_req req{ network_constants, hash, root }; + + channel->send ( + req, + [this] (auto & ec, auto size) { + if (ec) + { + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::write_error, nano::stat::dir::out); + } + }, + nano::transport::buffer_drop_policy::no_socket_drop); } else { From 5cc825627582e0671156ef967092c1b52d0be14f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 26 Feb 2024 17:57:23 +0100 Subject: [PATCH 125/190] Adjustments --- nano/node/repcrawler.cpp | 29 ++++++----------------------- nano/node/repcrawler.hpp | 3 +-- 2 files changed, 7 insertions(+), 25 deletions(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index d41916fdae..c89f142185 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -200,29 +200,18 @@ void nano::rep_crawler::cleanup () erase_if (reps, [this] (rep_entry const & rep) { if (!rep.channel->alive ()) { - logger.debug (nano::log::type::rep_crawler, "Evicting representative {} with dead channel at {}", rep.account.to_account (), rep.channel->to_string ()); + logger.info (nano::log::type::rep_crawler, "Evicting representative {} with dead channel at {}", rep.account.to_account (), rep.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::channel_dead); return true; // Erase } return false; }); - // Evict reps that haven't responded in a while - erase_if (reps, [this] (rep_entry const & rep) { - if (nano::elapsed (rep.last_response, config.rep_timeout)) - { - logger.debug (nano::log::type::rep_crawler, "Evicting unresponsive representative {} at {}", rep.account.to_account (), rep.channel->to_string ()); - stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::rep_timeout); - return true; // Erase - } - return false; - }); - // Evict queries that haven't been responded to in a while erase_if (queries, [this] (query_entry const & query) { if (nano::elapsed (query.time, config.query_timeout)) { - logger.debug (nano::log::type::rep_crawler, "Evicting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); + logger.debug (nano::log::type::rep_crawler, "Aborting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_timeout); return true; // Erase } @@ -235,9 +224,9 @@ std::vector> nano::rep_crawler::prepar debug_assert (!mutex.try_lock ()); // TODO: Make these values configurable - constexpr std::size_t conservative_count = 10; - constexpr std::size_t aggressive_count = 40; - constexpr std::size_t conservative_max_attempts = 1; + constexpr std::size_t conservative_count = 160; + constexpr std::size_t aggressive_count = 160; + constexpr std::size_t conservative_max_attempts = 4; constexpr std::size_t aggressive_max_attempts = 8; stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); @@ -245,7 +234,7 @@ std::vector> nano::rep_crawler::prepar // Crawl more aggressively if we lack sufficient total peer weight. auto const required_peer_count = sufficient_weight ? conservative_count : aggressive_count; - auto random_peers = node.network.random_set (required_peer_count, 0, /* Include channels with ephemeral remote ports */ true); + auto random_peers = node.network.random_set (required_peer_count, 0, /* include channels with ephemeral remote ports */ true); // Avoid querying the same peer multiple times when rep crawler is warmed up auto const max_attempts = sufficient_weight ? conservative_max_attempts : aggressive_max_attempts; @@ -500,7 +489,6 @@ nano::rep_crawler_config::rep_crawler_config (nano::network_constants const & ne { if (network_constants.is_dev_network ()) { - rep_timeout = std::chrono::milliseconds{ 1000 * 3 }; query_timeout = std::chrono::milliseconds{ 1000 }; } } @@ -508,7 +496,6 @@ nano::rep_crawler_config::rep_crawler_config (nano::network_constants const & ne nano::error nano::rep_crawler_config::serialize (nano::tomlconfig & toml) const { // TODO: Descriptions - toml.put ("rep_timeout", rep_timeout.count ()); toml.put ("query_timeout", query_timeout.count ()); return toml.get_error (); @@ -516,10 +503,6 @@ nano::error nano::rep_crawler_config::serialize (nano::tomlconfig & toml) const nano::error nano::rep_crawler_config::deserialize (nano::tomlconfig & toml) { - auto rep_timeout_l = rep_timeout.count (); - toml.get ("rep_timeout", rep_timeout_l); - rep_timeout = std::chrono::milliseconds{ rep_timeout_l }; - auto query_timeout_l = query_timeout.count (); toml.get ("query_timeout", query_timeout_l); query_timeout = std::chrono::milliseconds{ query_timeout_l }; diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index c7dab61a24..6e74cf3c54 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -40,8 +40,7 @@ class rep_crawler_config final nano::error serialize (nano::tomlconfig & toml) const; public: - std::chrono::milliseconds query_timeout{ 1000 * 30 }; - std::chrono::milliseconds rep_timeout{ 1000 * 60 * 5 }; + std::chrono::milliseconds query_timeout{ 1000 * 60 }; }; /** From 522f05cdf13fae567bdb0286dcd135581b85123f Mon Sep 17 00:00:00 2001 From: gr0vity-dev <85646666+gr0vity-dev@users.noreply.github.com> Date: Wed, 28 Feb 2024 13:52:25 +0100 Subject: [PATCH 126/190] Fix type to log ipc session_id (#4448) Co-authored-by: gr0vity-dev --- nano/node/ipc/ipc_server.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index 3b65534468..781f4051ac 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -36,7 +36,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f server (server_a), node (server_a.node), session_id (server_a.id_dispenser.fetch_add (1)), io_ctx (io_ctx_a), strand (io_ctx_a.get_executor ()), socket (io_ctx_a), config_transport (config_transport_a) { - node.logger.debug (nano::log::type::ipc, "Creating session with id: ", session_id.load ()); + node.logger.debug (nano::log::type::ipc, "Creating session with id: {}", session_id.load ()); } ~session () From 0ce830f5d6f4496aeb3a5823b5fc9e12eaf04dd9 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 4 Mar 2024 11:31:56 +0000 Subject: [PATCH 127/190] Process connection attempts in a round-robin fashion in order to load-balance connection attempts. # Conflicts: # nano/node/network.cpp --- nano/lib/config.hpp | 4 ++ nano/node/network.cpp | 2 - nano/node/transport/channel.hpp | 2 +- nano/node/transport/tcp.cpp | 72 ++++++++++++++++++++++++++++++ nano/node/transport/tcp.hpp | 2 + nano/node/transport/tcp_server.cpp | 10 +++++ nano/node/transport/tcp_server.hpp | 2 + 7 files changed, 91 insertions(+), 3 deletions(-) diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index a68b02c1b0..bddfa29cf9 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -202,6 +202,7 @@ class network_constants default_websocket_port (47000), aec_loop_interval_ms (300), // Update AEC ~3 times per second cleanup_period (default_cleanup_period), + merge_period (std::chrono::milliseconds (250)), keepalive_period (std::chrono::seconds (15)), idle_timeout (default_cleanup_period * 2), silent_connection_tolerance_time (std::chrono::seconds (120)), @@ -239,6 +240,7 @@ class network_constants { aec_loop_interval_ms = 20; cleanup_period = std::chrono::seconds (1); + merge_period = std::chrono::milliseconds (10); keepalive_period = std::chrono::seconds (1); idle_timeout = cleanup_period * 15; max_peers_per_ip = 20; @@ -277,6 +279,8 @@ class network_constants { return cleanup_period * 5; } + /** How often to connect to other peers */ + std::chrono::milliseconds merge_period; /** How often to send keepalive messages */ std::chrono::seconds keepalive_period; /** Default maximum idle time for a socket before it's automatically closed */ diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 4d47533be6..0c9cf2268c 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -239,8 +239,6 @@ class network_message_visitor : public nano::message_visitor void keepalive (nano::keepalive const & message_a) override { - node.network.merge_peers (message_a.peers); - // Check for special node port data auto peer0 (message_a.peers[0]); if (peer0.address () == boost::asio::ip::address_v6{} && peer0.port () != 0) diff --git a/nano/node/transport/channel.hpp b/nano/node/transport/channel.hpp index a16ee0e2ee..bede756ce3 100644 --- a/nano/node/transport/channel.hpp +++ b/nano/node/transport/channel.hpp @@ -187,4 +187,4 @@ struct hash> return hash (channel_a.get ()); } }; -} \ No newline at end of file +} diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index a085dbfc39..e6ddca6120 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -357,6 +357,7 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa void nano::transport::tcp_channels::start () { ongoing_keepalive (); + ongoing_merge (0); } void nano::transport::tcp_channels::stop () @@ -509,6 +510,77 @@ void nano::transport::tcp_channels::ongoing_keepalive () }); } +void nano::transport::tcp_channels::ongoing_merge (size_t channel_index) +{ + nano::unique_lock lock{ mutex }; + std::optional keepalive; + size_t count = 0; + while (!keepalive && channels.size () > 0 && count++ < channels.size ()) + { + ++channel_index; + if (channels.size () <= channel_index) + { + channel_index = 0; + } + auto server = channels.get ()[channel_index].response_server; + if (server && server->last_keepalive) + { + keepalive = std::move (server->last_keepalive); + server->last_keepalive = std::nullopt; + } + } + lock.unlock (); + if (keepalive) + { + ongoing_merge (channel_index, *keepalive, 1); + } + else + { + std::weak_ptr node_w = node.shared (); + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.merge_period, [node_w, channel_index] () { + if (auto node_l = node_w.lock ()) + { + if (!node_l->network.tcp_channels.stopped) + { + node_l->network.tcp_channels.ongoing_merge (channel_index); + } + } + }); + } +} + +void nano::transport::tcp_channels::ongoing_merge (size_t channel_index, nano::keepalive keepalive, size_t peer_index) +{ + debug_assert (peer_index < keepalive.peers.size ()); + node.network.merge_peer (keepalive.peers[peer_index++]); + if (peer_index < keepalive.peers.size ()) + { + std::weak_ptr node_w = node.shared (); + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.merge_period, [node_w, channel_index, keepalive, peer_index] () { + if (auto node_l = node_w.lock ()) + { + if (!node_l->network.tcp_channels.stopped) + { + node_l->network.tcp_channels.ongoing_merge (channel_index, keepalive, peer_index); + } + } + }); + } + else + { + std::weak_ptr node_w = node.shared (); + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.merge_period, [node_w, channel_index] () { + if (auto node_l = node_w.lock ()) + { + if (!node_l->network.tcp_channels.stopped) + { + node_l->network.tcp_channels.ongoing_merge (channel_index); + } + } + }); + } +} + void nano::transport::tcp_channels::list (std::deque> & deque_a, uint8_t minimum_version_a, bool include_temporary_channels_a) { nano::lock_guard lock{ mutex }; diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index 7b6efd9420..0f65b3bd0e 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -128,6 +128,8 @@ namespace transport std::unique_ptr collect_container_info (std::string const &); void purge (std::chrono::steady_clock::time_point const &); void ongoing_keepalive (); + void ongoing_merge (size_t channel_index); + void ongoing_merge (size_t channel_index, nano::keepalive keepalive, size_t peer_index); void list (std::deque> &, uint8_t = 0, bool = true); void modify (std::shared_ptr const &, std::function const &)>); void update (nano::tcp_endpoint const &); diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 7cfee60243..7e37ef97bc 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -623,6 +623,7 @@ nano::transport::tcp_server::realtime_message_visitor::realtime_message_visitor void nano::transport::tcp_server::realtime_message_visitor::keepalive (const nano::keepalive & message) { process = true; + server.set_last_keepalive (message); } void nano::transport::tcp_server::realtime_message_visitor::publish (const nano::publish & message) @@ -786,6 +787,15 @@ void nano::transport::tcp_server::timeout () } } +void nano::transport::tcp_server::set_last_keepalive (nano::keepalive const & message) +{ + std::lock_guard lock{ mutex }; + if (!last_keepalive) + { + last_keepalive = message; + } +} + bool nano::transport::tcp_server::to_bootstrap_connection () { auto node = this->node.lock (); diff --git a/nano/node/transport/tcp_server.hpp b/nano/node/transport/tcp_server.hpp index e011c50630..5369258545 100644 --- a/nano/node/transport/tcp_server.hpp +++ b/nano/node/transport/tcp_server.hpp @@ -62,6 +62,7 @@ class tcp_server final : public std::enable_shared_from_this void stop (); void timeout (); + void set_last_keepalive (nano::keepalive const & message); std::shared_ptr const socket; std::weak_ptr const node; @@ -72,6 +73,7 @@ class tcp_server final : public std::enable_shared_from_this nano::tcp_endpoint remote_endpoint{ boost::asio::ip::address_v6::any (), 0 }; nano::account remote_node_id{}; std::chrono::steady_clock::time_point last_telemetry_req{}; + std::optional last_keepalive; private: void send_handshake_response (nano::node_id_handshake::query_payload const & query, bool v2); From 1b1bac07ab06241aa164ae12b54da4e5dfe4784d Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Mon, 26 Feb 2024 10:52:19 +0000 Subject: [PATCH 128/190] Increasing block processing timeout default from 15 to 300 seconds. --- nano/node/nodeconfig.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 8f7580534a..55b14db049 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -88,7 +88,7 @@ class node_config uint16_t external_port{ 0 }; std::chrono::milliseconds block_processor_batch_max_time{ std::chrono::milliseconds (500) }; /** Time to wait for block processing result */ - std::chrono::seconds block_process_timeout{ 15 }; + std::chrono::seconds block_process_timeout{ 300 }; std::chrono::seconds unchecked_cutoff_time{ std::chrono::seconds (4 * 60 * 60) }; // 4 hours /** Timeout for initiated async operations */ std::chrono::seconds tcp_io_timeout{ (network_params.network.is_dev_network () && !is_sanitizer_build ()) ? std::chrono::seconds (5) : std::chrono::seconds (15) }; From 69db556656d8e024f97e03018f36dec07c631fd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 5 Mar 2024 12:44:05 +0100 Subject: [PATCH 129/190] Use start/stop pattern in `vote_processor` (#4455) --- nano/node/node.cpp | 1 + nano/node/vote_processor.cpp | 69 ++++++++++++++++++------------------ nano/node/vote_processor.hpp | 28 +++++++++------ 3 files changed, 53 insertions(+), 45 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 834cabbd9f..ac5f56b2c9 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -646,6 +646,7 @@ void nano::node::start () port_mapping.start (); } wallets.start (); + vote_processor.start (); active.start (); generator.start (); final_generator.start (); diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 524dbdc8ee..9c094abf45 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -1,4 +1,3 @@ - #include #include #include @@ -13,6 +12,7 @@ #include #include + using namespace std::chrono_literals; nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : @@ -25,33 +25,45 @@ nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano rep_crawler (rep_crawler_a), ledger (ledger_a), network_params (network_params_a), - max_votes (flags_a.vote_processor_capacity), - started (false), - stopped (false), - thread ([this] () { + max_votes (flags_a.vote_processor_capacity) +{ +} + +nano::vote_processor::~vote_processor () +{ + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); +} + +void nano::vote_processor::start () +{ + debug_assert (!thread.joinable ()); + + thread = std::thread{ [this] () { nano::thread_role::set (nano::thread_role::name::vote_processing); - process_loop (); - nano::unique_lock lock{ mutex }; - votes.clear (); - condition.notify_all (); - }) + run (); + } }; +} + +void nano::vote_processor::stop () { - nano::unique_lock lock{ mutex }; - condition.wait (lock, [&started = started] { return started; }); + { + nano::lock_guard lock{ mutex }; + stopped = true; + } + condition.notify_all (); + if (thread.joinable ()) + { + thread.join (); + } } -void nano::vote_processor::process_loop () +void nano::vote_processor::run () { nano::timer elapsed; bool log_this_iteration; nano::unique_lock lock{ mutex }; - started = true; - - lock.unlock (); - condition.notify_all (); - lock.lock (); - while (!stopped) { if (!votes.empty ()) @@ -181,19 +193,6 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr return result; } -void nano::vote_processor::stop () -{ - { - nano::lock_guard lock{ mutex }; - stopped = true; - } - condition.notify_all (); - if (thread.joinable ()) - { - thread.join (); - } -} - void nano::vote_processor::flush () { nano::unique_lock lock{ mutex }; @@ -208,19 +207,19 @@ void nano::vote_processor::flush () } } -std::size_t nano::vote_processor::size () +std::size_t nano::vote_processor::size () const { nano::lock_guard guard{ mutex }; return votes.size (); } -bool nano::vote_processor::empty () +bool nano::vote_processor::empty () const { nano::lock_guard guard{ mutex }; return votes.empty (); } -bool nano::vote_processor::half_full () +bool nano::vote_processor::half_full () const { return size () >= max_votes / 2; } diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index dbcacc41c3..4591c5ee71 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -37,6 +37,10 @@ class vote_processor final { public: vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger &, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); + ~vote_processor (); + + void start (); + void stop (); /** Returns false if the vote was processed */ bool vote (std::shared_ptr const &, std::shared_ptr const &); @@ -46,16 +50,14 @@ class vote_processor final /** Function blocks until either the current queue size (a established flush boundary as it'll continue to increase) * is processed or the queue is empty (end condition or cutoff's guard, as it is positioned ahead) */ void flush (); - std::size_t size (); - bool empty (); - bool half_full (); + std::size_t size () const; + bool empty () const; + bool half_full () const; void calculate_weights (); - void stop (); - std::atomic total_processed{ 0 }; -private: - void process_loop (); + std::atomic total_processed{ 0 }; +private: // Dependencies nano::active_transactions & active; nano::node_observers & observers; nano::stats & stats; @@ -65,16 +67,22 @@ class vote_processor final nano::rep_crawler & rep_crawler; nano::ledger & ledger; nano::network_params & network_params; + +private: + void run (); + std::size_t const max_votes; std::deque, std::shared_ptr>> votes; + /** Representatives levels for random early detection */ std::unordered_set representatives_1; std::unordered_set representatives_2; std::unordered_set representatives_3; + +private: + bool stopped{ false }; nano::condition_variable condition; - nano::mutex mutex{ mutex_identifier (mutexes::vote_processor) }; - bool started; - bool stopped; + mutable nano::mutex mutex{ mutex_identifier (mutexes::vote_processor) }; std::thread thread; friend std::unique_ptr collect_container_info (vote_processor & vote_processor, std::string const & name); From 65de6fe3e5546e78b0fae482314c178fd4d940d1 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 5 Mar 2024 12:02:17 +0000 Subject: [PATCH 130/190] Remove unused ledger::could_fit (#4457) --- nano/core_test/ledger.cpp | 142 -------------------------------------- nano/secure/ledger.cpp | 8 --- nano/secure/ledger.hpp | 1 - 3 files changed, 151 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 821d1d4994..9f6aee9416 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -4158,148 +4158,6 @@ TEST (ledger, block_hash_account_conflict) ASSERT_EQ (*open_epoch1, *winner4); } -TEST (ledger, could_fit) -{ - nano::logger logger; - auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stats stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); - nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; - nano::keypair destination; - // Test legacy and state change blocks could_fit - nano::block_builder builder; - auto change1 = builder - .change () - .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (nano::dev::genesis->hash ())) - .build (); - auto change2 = builder - .state () - .account (nano::dev::genesis->account ()) - .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) - .balance (nano::dev::constants.genesis_amount) - .link (0) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (nano::dev::genesis->hash ())) - .build (); - ASSERT_TRUE (ledger.could_fit (transaction, *change1)); - ASSERT_TRUE (ledger.could_fit (transaction, *change2)); - // Test legacy and state send - nano::keypair key1; - auto send1 = builder - .send () - .previous (change1->hash ()) - .destination (key1.pub) - .balance (nano::dev::constants.genesis_amount - 1) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (change1->hash ())) - .build (); - auto send2 = builder - .state () - .account (nano::dev::genesis->account ()) - .previous (change1->hash ()) - .representative (nano::dev::genesis->account ()) - .balance (nano::dev::constants.genesis_amount - 1) - .link (key1.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (change1->hash ())) - .build (); - ASSERT_FALSE (ledger.could_fit (transaction, *send1)); - ASSERT_FALSE (ledger.could_fit (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); - ASSERT_TRUE (ledger.could_fit (transaction, *change1)); - ASSERT_TRUE (ledger.could_fit (transaction, *change2)); - ASSERT_TRUE (ledger.could_fit (transaction, *send1)); - ASSERT_TRUE (ledger.could_fit (transaction, *send2)); - // Test legacy and state open - auto open1 = builder - .open () - .source (send2->hash ()) - .representative (nano::dev::genesis->account ()) - .account (key1.pub) - .sign (key1.prv, key1.pub) - .work (*pool.generate (key1.pub)) - .build (); - auto open2 = builder - .state () - .account (key1.pub) - .previous (0) - .representative (nano::dev::genesis->account ()) - .balance (1) - .link (send2->hash ()) - .sign (key1.prv, key1.pub) - .work (*pool.generate (key1.pub)) - .build (); - ASSERT_FALSE (ledger.could_fit (transaction, *open1)); - ASSERT_FALSE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); - ASSERT_TRUE (ledger.could_fit (transaction, *send1)); - ASSERT_TRUE (ledger.could_fit (transaction, *send2)); - ASSERT_TRUE (ledger.could_fit (transaction, *open1)); - ASSERT_TRUE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); - ASSERT_TRUE (ledger.could_fit (transaction, *open1)); - ASSERT_TRUE (ledger.could_fit (transaction, *open2)); - // Create another send to receive - auto send3 = builder - .state () - .account (nano::dev::genesis->account ()) - .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) - .balance (nano::dev::constants.genesis_amount - 2) - .link (key1.pub) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (send2->hash ())) - .build (); - // Test legacy and state receive - auto receive1 = builder - .receive () - .previous (open1->hash ()) - .source (send3->hash ()) - .sign (key1.prv, key1.pub) - .work (*pool.generate (open1->hash ())) - .build (); - auto receive2 = builder - .state () - .account (key1.pub) - .previous (open1->hash ()) - .representative (nano::dev::genesis->account ()) - .balance (2) - .link (send3->hash ()) - .sign (key1.prv, key1.pub) - .work (*pool.generate (open1->hash ())) - .build (); - ASSERT_FALSE (ledger.could_fit (transaction, *receive1)); - ASSERT_FALSE (ledger.could_fit (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); - ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); - ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); - // Test epoch (state) - auto epoch1 = builder - .state () - .account (key1.pub) - .previous (receive1->hash ()) - .representative (nano::dev::genesis->account ()) - .balance (2) - .link (ledger.epoch_link (nano::epoch::epoch_1)) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*pool.generate (receive1->hash ())) - .build (); - ASSERT_FALSE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); - ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); - ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); - ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); -} - TEST (ledger, unchecked_epoch) { nano::test::system system (1); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index c23ffc73b4..dc2651b89a 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1244,14 +1244,6 @@ void nano::ledger::dump_account_chain (nano::account const & account_a, std::ost } } -bool nano::ledger::could_fit (store::transaction const & transaction_a, nano::block const & block_a) const -{ - auto dependencies (dependent_blocks (transaction_a, block_a)); - return std::all_of (dependencies.begin (), dependencies.end (), [this, &transaction_a] (nano::block_hash const & hash_a) { - return hash_a.is_zero () || store.block.exists (transaction_a, hash_a); - }); -} - bool nano::ledger::dependents_confirmed (store::transaction const & transaction_a, nano::block const & block_a) const { auto dependencies (dependent_blocks (transaction_a, block_a)); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 935f57e2cb..ac6206e6ea 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -78,7 +78,6 @@ class ledger final void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &); uint64_t pruning_action (store::write_transaction &, nano::block_hash const &, uint64_t const); void dump_account_chain (nano::account const &, std::ostream & = std::cout); - bool could_fit (store::transaction const &, nano::block const &) const; bool dependents_confirmed (store::transaction const &, nano::block const &) const; bool is_epoch_link (nano::link const &) const; std::array dependent_blocks (store::transaction const &, nano::block const &) const; From 3ddfd780e4a479a6b33f374b036bfb11eb8498c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 5 Mar 2024 13:11:17 +0100 Subject: [PATCH 131/190] Throttle queries to active reps --- nano/node/repcrawler.cpp | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index c89f142185..7934370b2a 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -228,6 +228,7 @@ std::vector> nano::rep_crawler::prepar constexpr std::size_t aggressive_count = 160; constexpr std::size_t conservative_max_attempts = 4; constexpr std::size_t aggressive_max_attempts = 8; + constexpr std::chrono::seconds rep_query_interval = std::chrono::seconds{ 60 }; stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); @@ -236,10 +237,22 @@ std::vector> nano::rep_crawler::prepar auto random_peers = node.network.random_set (required_peer_count, 0, /* include channels with ephemeral remote ports */ true); - // Avoid querying the same peer multiple times when rep crawler is warmed up - auto const max_attempts = sufficient_weight ? conservative_max_attempts : aggressive_max_attempts; - erase_if (random_peers, [this, max_attempts] (std::shared_ptr const & channel) { - return queries.get ().count (channel) >= max_attempts; + auto should_query = [&, this] (std::shared_ptr const & channel) { + if (auto rep = reps.get ().find (channel); rep != reps.get ().end ()) + { + // Throttle queries to active reps + return elapsed (rep->last_request, rep_query_interval); + } + else + { + // Avoid querying the same peer multiple times when rep crawler is warmed up + auto const max_attempts = sufficient_weight ? conservative_max_attempts : aggressive_max_attempts; + return queries.get ().count (channel) < max_attempts; + } + }; + + erase_if (random_peers, [&, this] (std::shared_ptr const & channel) { + return !should_query (channel); }); return { random_peers.begin (), random_peers.end () }; From 665296acfaf376fb8449fd4813a08ddc1459a668 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 5 Mar 2024 14:02:33 +0000 Subject: [PATCH 132/190] Reduce coupling to store.block.get by using ledger::block interface. --- nano/core_test/block_store.cpp | 24 ++--- nano/core_test/ledger.cpp | 38 +++---- nano/core_test/wallet.cpp | 4 +- nano/nano_node/entry.cpp | 14 +-- nano/node/bootstrap/bootstrap_server.cpp | 6 +- nano/node/confirmation_height_bounded.cpp | 14 +-- nano/node/confirmation_height_unbounded.cpp | 4 +- nano/node/json_handler.cpp | 52 ++++----- nano/node/node.cpp | 7 +- nano/node/request_aggregator.cpp | 8 +- nano/node/scheduler/hinted.cpp | 4 +- nano/node/scheduler/priority.cpp | 2 +- nano/node/voting.cpp | 2 +- nano/node/wallet.cpp | 4 +- nano/qt/qt.cpp | 10 +- nano/rpc_test/rpc.cpp | 6 +- nano/secure/ledger.cpp | 113 ++++++++++---------- nano/secure/ledger.hpp | 1 + nano/slow_test/node.cpp | 4 +- nano/test_common/system.cpp | 2 +- 20 files changed, 162 insertions(+), 157 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 6f010ee266..56f1c838f5 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1126,29 +1126,29 @@ TEST (mdb_block_store, sideband_height) .work (*pool.generate (key3.pub)) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); - auto block1 (store.block.get (transaction, nano::dev::genesis->hash ())); + auto block1 = ledger.block (transaction, nano::dev::genesis->hash ()); ASSERT_EQ (block1->sideband ().height, 1); - auto block2 (store.block.get (transaction, send->hash ())); + auto block2 = ledger.block (transaction, send->hash ()); ASSERT_EQ (block2->sideband ().height, 2); - auto block3 (store.block.get (transaction, receive->hash ())); + auto block3 = ledger.block (transaction, receive->hash ()); ASSERT_EQ (block3->sideband ().height, 3); - auto block4 (store.block.get (transaction, change->hash ())); + auto block4 = ledger.block (transaction, change->hash ()); ASSERT_EQ (block4->sideband ().height, 4); - auto block5 (store.block.get (transaction, state_send1->hash ())); + auto block5 = ledger.block (transaction, state_send1->hash ()); ASSERT_EQ (block5->sideband ().height, 5); - auto block6 (store.block.get (transaction, state_send2->hash ())); + auto block6 = ledger.block (transaction, state_send2->hash ()); ASSERT_EQ (block6->sideband ().height, 6); - auto block7 (store.block.get (transaction, state_send3->hash ())); + auto block7 = ledger.block (transaction, state_send3->hash ()); ASSERT_EQ (block7->sideband ().height, 7); - auto block8 (store.block.get (transaction, state_open->hash ())); + auto block8 = ledger.block (transaction, state_open->hash ()); ASSERT_EQ (block8->sideband ().height, 1); - auto block9 (store.block.get (transaction, epoch->hash ())); + auto block9 = ledger.block (transaction, epoch->hash ()); ASSERT_EQ (block9->sideband ().height, 2); - auto block10 (store.block.get (transaction, epoch_open->hash ())); + auto block10 = ledger.block (transaction, epoch_open->hash ()); ASSERT_EQ (block10->sideband ().height, 1); - auto block11 (store.block.get (transaction, state_receive->hash ())); + auto block11 = ledger.block (transaction, state_receive->hash ()); ASSERT_EQ (block11->sideband ().height, 2); - auto block12 (store.block.get (transaction, open->hash ())); + auto block12 = ledger.block (transaction, open->hash ()); ASSERT_EQ (block12->sideband ().height, 1); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 9f6aee9416..1436e3006f 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -78,7 +78,7 @@ TEST (ledger, process_modifies_sideband) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send1)); - ASSERT_EQ (send1->sideband ().timestamp, store.block.get (store.tx_begin_read (), send1->hash ())->sideband ().timestamp); + ASSERT_EQ (send1->sideband ().timestamp, ledger.block (store.tx_begin_read (), send1->hash ())->sideband ().timestamp); } // Create a send block and publish it. @@ -118,7 +118,7 @@ TEST (ledger, process_send) auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info2); ASSERT_EQ (2, info2->block_count); - auto latest6 = store.block.get (transaction, info2->head); + auto latest6 = ledger.block (transaction, info2->head); ASSERT_NE (nullptr, latest6); auto latest7 = dynamic_cast (latest6.get ()); ASSERT_NE (nullptr, latest7); @@ -150,14 +150,14 @@ TEST (ledger, process_send) ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key2.pub)); auto info3 = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info3); - auto latest2 = store.block.get (transaction, info3->head); + auto latest2 = ledger.block (transaction, info3->head); ASSERT_NE (nullptr, latest2); auto latest3 = dynamic_cast (latest2.get ()); ASSERT_NE (nullptr, latest3); ASSERT_EQ (*send, *latest3); auto info4 = ledger.account_info (transaction, key2.pub); ASSERT_TRUE (info4); - auto latest4 = store.block.get (transaction, info4->head); + auto latest4 = ledger.block (transaction, info4->head); ASSERT_NE (nullptr, latest4); auto latest5 = dynamic_cast (latest4.get ()); ASSERT_NE (nullptr, latest5); @@ -2383,7 +2383,7 @@ TEST (ledger, state_send_receive) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2406,7 +2406,7 @@ TEST (ledger, state_send_receive) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); - auto receive2 = store.block.get (transaction, receive1->hash ()); + auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); @@ -2438,7 +2438,7 @@ TEST (ledger, state_receive) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2456,7 +2456,7 @@ TEST (ledger, state_receive) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); - auto receive2 = store.block.get (transaction, receive1->hash ()); + auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); @@ -2489,7 +2489,7 @@ TEST (ledger, state_rep_change) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_TRUE (store.block.exists (transaction, change1->hash ())); - auto change2 = store.block.get (transaction, change1->hash ()); + auto change2 = ledger.block (transaction, change1->hash ()); ASSERT_NE (nullptr, change2); ASSERT_EQ (*change1, *change2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, change1->hash ())); @@ -2523,7 +2523,7 @@ TEST (ledger, state_open) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2543,7 +2543,7 @@ TEST (ledger, state_open) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); ASSERT_TRUE (store.block.exists (transaction, open1->hash ())); - auto open2 = store.block.get (transaction, open1->hash ()); + auto open2 = ledger.block (transaction, open1->hash ()); ASSERT_NE (nullptr, open2); ASSERT_EQ (*open1, *open2); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); @@ -2666,7 +2666,7 @@ TEST (ledger, state_unreceivable_fail) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2703,7 +2703,7 @@ TEST (ledger, state_receive_bad_amount_fail) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2775,7 +2775,7 @@ TEST (ledger, state_receive_wrong_account_fail) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2969,7 +2969,7 @@ TEST (ledger, state_send_change) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -3002,7 +3002,7 @@ TEST (ledger, state_receive_change) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -3021,7 +3021,7 @@ TEST (ledger, state_receive_change) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); - auto receive2 = store.block.get (transaction, receive1->hash ()); + auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); @@ -3141,7 +3141,7 @@ TEST (ledger, state_rollback_send) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); - auto send2 = store.block.get (transaction, send1->hash ()); + auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -4291,7 +4291,7 @@ TEST (ledger, unchecked_epoch_invalid) auto info = node1.ledger.account_info (transaction, destination.pub); ASSERT_TRUE (info); ASSERT_NE (info->epoch (), nano::epoch::epoch_1); - auto epoch2_store = node1.store.block.get (transaction, epoch2->hash ()); + auto epoch2_store = node1.ledger.block (transaction, epoch2->hash ()); ASSERT_NE (nullptr, epoch2_store); ASSERT_EQ (nano::epoch::epoch_0, epoch2_store->sideband ().details.epoch); ASSERT_TRUE (epoch2_store->sideband ().details.is_send); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index c6fec45f5f..cbfa73eb9d 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -181,7 +181,7 @@ TEST (wallet, spend_all_one) auto transaction (node1.store.tx_begin_read ()); auto info2 = node1.ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_NE (latest1, info2->head); - auto block (node1.store.block.get (transaction, info2->head)); + auto block = node1.ledger.block (transaction, info2->head); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); ASSERT_TRUE (info2->balance.is_zero ()); @@ -216,7 +216,7 @@ TEST (wallet, spend) auto info2 = node1.ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info2); ASSERT_NE (latest1, info2->head); - auto block (node1.store.block.get (transaction, info2->head)); + auto block = node1.ledger.block (transaction, info2->head); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); ASSERT_TRUE (info2->balance.is_zero ()); diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 534c368adc..744df8d63b 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1411,17 +1411,17 @@ int main (int argc, char * const * argv) auto hash (info.open_block); nano::block_hash calculated_hash (0); - auto block (node->store.block.get (transaction, hash)); // Block data + auto block = node->ledger.block (transaction, hash); // Block data uint64_t height (0); if (node->ledger.pruning && confirmation_height_info.height != 0) { hash = confirmation_height_info.frontier; - block = node->store.block.get (transaction, hash); + block = node->ledger.block (transaction, hash); // Iteration until pruned block bool pruned_block (false); while (!pruned_block && !block->previous ().is_zero ()) { - auto previous_block (node->store.block.get (transaction, block->previous ())); + auto previous_block = node->ledger.block (transaction, block->previous ()); if (previous_block != nullptr) { hash = previous_block->hash (); @@ -1591,7 +1591,7 @@ int main (int argc, char * const * argv) // Retrieving block data if (!hash.is_zero ()) { - block = node->store.block.get (transaction, hash); + block = node->ledger.block (transaction, hash); } } // Check if required block exists @@ -1676,7 +1676,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("%1% pending blocks validated\n") % count); } // Check block existance - auto block (node->store.block.get (transaction, key.hash)); + auto block = node->ledger.block (transaction, key.hash); bool pruned (false); if (block == nullptr) { @@ -1693,7 +1693,7 @@ int main (int argc, char * const * argv) bool previous_pruned = node->ledger.pruning && node->store.pruned.exists (transaction, block->previous ()); if (previous_pruned) { - block = node->store.block.get (transaction, key.hash); + block = node->ledger.block (transaction, key.hash); } if (auto state = dynamic_cast (block.get ())) { @@ -1800,7 +1800,7 @@ int main (int argc, char * const * argv) while (!hash.is_zero ()) { // Retrieving block data - auto block (source_node->store.block.get (transaction, hash)); + auto block = source_node->ledger.block (transaction, hash); if (block != nullptr) { ++count; diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 8fda11587c..258eb4e883 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -253,13 +253,13 @@ std::vector> nano::bootstrap_server::prepare_blocks std::vector> result; if (!start_block.is_zero ()) { - std::shared_ptr current = store.block.get (transaction, start_block); + std::shared_ptr current = ledger.block (transaction, start_block); while (current && result.size () < count) { result.push_back (current); auto successor = current->sideband ().successor; - current = store.block.get (transaction, successor); + current = ledger.block (transaction, successor); } } return result; @@ -337,4 +337,4 @@ nano::asc_pull_ack nano::bootstrap_server::process (const store::transaction & t response.payload = response_payload; response.update_header (); return response; -} \ No newline at end of file +} diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 9136dc7c5d..f2ed6623ac 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -83,7 +83,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or } else { - block = ledger.store.block.get (transaction, current); + block = ledger.block (transaction, current); } if (!block) @@ -227,7 +227,7 @@ nano::block_hash nano::confirmation_height_bounded::get_least_unconfirmed_hash_f { if (block_height_a > confirmation_height_info_a.height) { - auto block (ledger.store.block.get (transaction_a, confirmation_height_info_a.frontier)); + auto block = ledger.block (transaction_a, confirmation_height_info_a.frontier); release_assert (block != nullptr); least_unconfirmed_hash = block->sideband ().successor; block_height_a = block->sideband ().height + 1; @@ -255,7 +255,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & // Keep iterating upwards until we either reach the desired block or the second receive. // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; - auto block = ledger.store.block.get (transaction_a, hash); + auto block = ledger.block (transaction_a, hash); auto source (block->source ()); if (source.is_zero ()) { @@ -384,7 +384,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope // Extra debug checks nano::confirmation_height_info confirmation_height_info; ledger.store.confirmation_height.get (transaction, account, confirmation_height_info); - auto block (ledger.store.block.get (transaction, confirmed_frontier)); + auto block = ledger.block (transaction, confirmed_frontier); debug_assert (block != nullptr); debug_assert (block->sideband ().height == confirmation_height_info.height + num_blocks_cemented); #endif @@ -414,14 +414,14 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope } else { - auto block = ledger.store.block.get (transaction, confirmation_height_info.frontier); + auto block = ledger.block (transaction, confirmation_height_info.frontier); new_cemented_frontier = block->sideband ().successor; num_blocks_confirmed = pending.top_height - confirmation_height_info.height; start_height = confirmation_height_info.height + 1; } auto total_blocks_cemented = 0; - auto block = ledger.store.block.get (transaction, new_cemented_frontier); + auto block = ledger.block (transaction, new_cemented_frontier); // Cementing starts from the bottom of the chain and works upwards. This is because chains can have effectively // an infinite number of send/change blocks in a row. We don't want to hold the write transaction open for too long. @@ -480,7 +480,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope if (!last_iteration) { new_cemented_frontier = block->sideband ().successor; - block = ledger.store.block.get (transaction, new_cemented_frontier); + block = ledger.block (transaction, new_cemented_frontier); } else { diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 8f50f39dcb..e99766d1ba 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -376,7 +376,7 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco auto confirmation_height = confirmation_height_info.height; if (pending.height > confirmation_height) { - auto block = ledger.store.block.get (transaction, pending.hash); + auto block = ledger.block (transaction, pending.hash); debug_assert (ledger.pruning || block != nullptr); debug_assert (ledger.pruning || block->sideband ().height == pending.height); @@ -438,7 +438,7 @@ std::shared_ptr nano::confirmation_height_unbounded::get_block_and_ } else { - auto block (ledger.store.block.get (transaction_a, hash_a)); + auto block = ledger.block (transaction_a, hash_a); block_cache.emplace (hash_a, block); return block; } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index c84a257b14..d50bacdd16 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -397,7 +397,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) auto previous (block_a.previous ()); if (!previous.is_zero ()) { - block_previous = node.store.block.get (transaction, previous); + block_previous = node.ledger.block (transaction, previous); } // Send check if (block_previous != nullptr) @@ -413,7 +413,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) auto link (block_a.link ()); if (!link.is_zero () && !details.is_send) { - auto block_link (node.store.block.get (transaction, link.as_block_hash ())); + auto block_link = node.ledger.block (transaction, link.as_block_hash ()); if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ()))) { details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); @@ -672,7 +672,7 @@ void nano::json_handler::account_info () std::shared_ptr confirmed_frontier_block; if (include_confirmed && confirmation_height_info.height > 0) { - confirmed_frontier_block = node.store.block.get (transaction, confirmation_height_info.frontier); + confirmed_frontier_block = node.ledger.block (transaction, confirmation_height_info.frontier); } if (representative) @@ -686,7 +686,7 @@ void nano::json_handler::account_info () confirmed_representative = confirmed_frontier_block->representative (); if (confirmed_representative.is_zero ()) { - confirmed_representative = node.store.block.get (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative (); + confirmed_representative = node.ledger.block (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative (); } } @@ -1145,7 +1145,7 @@ void nano::json_handler::block_info () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); if (block != nullptr) { nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); @@ -1197,7 +1197,7 @@ void nano::json_handler::block_confirm () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block_l (node.store.block.get (transaction, hash)); + auto block_l = node.ledger.block (transaction, hash); if (block_l != nullptr) { if (!node.ledger.block_confirmed (transaction, hash)) @@ -1252,7 +1252,7 @@ void nano::json_handler::blocks () nano::block_hash hash; if (!hash.decode_hex (hash_text)) { - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); if (block != nullptr) { if (json_block_l) @@ -1303,7 +1303,7 @@ void nano::json_handler::blocks_info () nano::block_hash hash; if (!hash.decode_hex (hash_text)) { - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); if (block != nullptr) { boost::property_tree::ptree entry; @@ -1385,7 +1385,7 @@ void nano::json_handler::blocks_info () if (source) { nano::block_hash source_hash (node.ledger.block_source (transaction, *block)); - auto block_a (node.store.block.get (transaction, source_hash)); + auto block_a = node.ledger.block (transaction, source_hash); if (block_a != nullptr) { auto source_account (node.ledger.account (transaction, source_hash)); @@ -1945,7 +1945,7 @@ void nano::json_handler::chain (bool successors) auto transaction (node.store.tx_begin_read ()); while (!hash.is_zero () && blocks.size () < count) { - auto block_l (node.store.block.get (transaction, hash)); + auto block_l = node.ledger.block (transaction, hash); if (block_l != nullptr) { if (offset > 0) @@ -2643,7 +2643,7 @@ void nano::json_handler::account_history () boost::property_tree::ptree history; bool output_raw (request.get_optional ("raw") == true); response_l.put ("account", account.to_account ()); - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); while (block != nullptr && count > 0) { if (offset > 0) @@ -2671,7 +2671,7 @@ void nano::json_handler::account_history () } } hash = reverse ? node.store.block.successor (transaction, hash) : block->previous (); - block = node.store.block.get (transaction, hash); + block = node.ledger.block (transaction, hash); } response_l.add_child ("history", history); if (!hash.is_zero ()) @@ -3164,7 +3164,7 @@ void nano::json_handler::receivable_exists () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); if (block != nullptr) { auto exists (false); @@ -3638,28 +3638,28 @@ void nano::json_handler::republish () { boost::property_tree::ptree blocks; auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); if (block != nullptr) { std::deque> republish_bundle; for (auto i (0); !hash.is_zero () && i < count; ++i) { - block = node.store.block.get (transaction, hash); + block = node.ledger.block (transaction, hash); if (sources != 0) // Republish source chain { nano::block_hash source (node.ledger.block_source (transaction, *block)); - auto block_a (node.store.block.get (transaction, source)); + auto block_a = node.ledger.block (transaction, source); std::vector hashes; while (block_a != nullptr && hashes.size () < sources) { hashes.push_back (source); source = block_a->previous (); - block_a = node.store.block.get (transaction, source); + block_a = node.ledger.block (transaction, source); } std::reverse (hashes.begin (), hashes.end ()); for (auto & hash_l : hashes) { - block_a = node.store.block.get (transaction, hash_l); + block_a = node.ledger.block (transaction, hash_l); republish_bundle.push_back (std::move (block_a)); boost::property_tree::ptree entry_l; entry_l.put ("", hash_l.to_string ()); @@ -3672,14 +3672,14 @@ void nano::json_handler::republish () blocks.push_back (std::make_pair ("", entry)); if (destinations != 0) // Republish destination chain { - auto block_b (node.store.block.get (transaction, hash)); + auto block_b = node.ledger.block (transaction, hash); auto destination (node.ledger.block_destination (transaction, *block_b)); if (!destination.is_zero ()) { if (!node.store.pending.exists (transaction, nano::pending_key (destination, hash))) { nano::block_hash previous (node.ledger.latest (transaction, destination)); - auto block_d (node.store.block.get (transaction, previous)); + auto block_d = node.ledger.block (transaction, previous); nano::block_hash source; std::vector hashes; while (block_d != nullptr && hash != source) @@ -3687,7 +3687,7 @@ void nano::json_handler::republish () hashes.push_back (previous); source = node.ledger.block_source (transaction, *block_d); previous = block_d->previous (); - block_d = node.store.block.get (transaction, previous); + block_d = node.ledger.block (transaction, previous); } std::reverse (hashes.begin (), hashes.end ()); if (hashes.size () > destinations) @@ -3696,7 +3696,7 @@ void nano::json_handler::republish () } for (auto & hash_l : hashes) { - block_d = node.store.block.get (transaction, hash_l); + block_d = node.ledger.block (transaction, hash_l); republish_bundle.push_back (std::move (block_d)); boost::property_tree::ptree entry_l; entry_l.put ("", hash_l.to_string ()); @@ -4658,7 +4658,7 @@ void nano::json_handler::wallet_history () auto hash (info->head); while (timestamp >= modified_since && !hash.is_zero ()) { - auto block (node.store.block.get (block_transaction, hash)); + auto block = node.ledger.block (block_transaction, hash); timestamp = block->sideband ().timestamp; if (block != nullptr && timestamp >= modified_since) { @@ -4932,7 +4932,7 @@ void nano::json_handler::wallet_republish () while (!latest.is_zero () && hashes.size () < count) { hashes.push_back (latest); - block = node.store.block.get (block_transaction, latest); + block = node.ledger.block (block_transaction, latest); if (block != nullptr) { latest = block->previous (); @@ -4945,7 +4945,7 @@ void nano::json_handler::wallet_republish () std::reverse (hashes.begin (), hashes.end ()); for (auto & hash : hashes) { - block = node.store.block.get (block_transaction, hash); + block = node.ledger.block (block_transaction, hash); republish_bundle.push_back (std::move (block)); boost::property_tree::ptree entry; entry.put ("", hash.to_string ()); @@ -5463,7 +5463,7 @@ bool block_confirmed (nano::node & node, nano::store::transaction & transaction, // This just checks it's not currently undergoing an active transaction else if (!include_only_confirmed) { - auto block (node.store.block.get (transaction, hash)); + auto block = node.ledger.block (transaction, hash); is_confirmed = (block != nullptr && !node.active.active (*block)); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index ac5f56b2c9..b3da87e61a 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -727,8 +727,7 @@ nano::uint128_t nano::node::balance (nano::account const & account_a) std::shared_ptr nano::node::block (nano::block_hash const & hash_a) { - auto const transaction (store.tx_begin_read ()); - return store.block.get (transaction, hash_a); + return ledger.block (store.tx_begin_read (), hash_a); } std::pair nano::node::balance_pending (nano::account const & account_a, bool only_confirmed_a) @@ -921,7 +920,7 @@ bool nano::node::collect_ledger_pruning_targets (std::deque & uint64_t depth (0); while (!hash.is_zero () && depth < max_depth_a) { - auto block (store.block.get (transaction, hash)); + auto block = ledger.block (transaction, hash); if (block != nullptr) { if (block->sideband ().timestamp > cutoff_time_a || depth == 0) @@ -1271,7 +1270,7 @@ void nano::node::process_confirmed (nano::election_status const & status_a, uint { auto hash (status_a.winner->hash ()); decltype (iteration_a) const num_iters = (config.block_processor_batch_max_time / network_params.node.process_confirmed_interval) * 4; - if (auto block_l = ledger.store.block.get (ledger.store.tx_begin_read (), hash)) + if (auto block_l = ledger.block (ledger.store.tx_begin_read (), hash)) { logger.trace (nano::log::type::node, nano::log::detail::process_confirmed, nano::log::arg{ "block", block_l }); diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index bb60519824..452f0e0ba0 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -204,12 +204,12 @@ std::pair>, std::vector 1) { to_generate_final.push_back (block); - block = ledger.store.block.get (transaction, final_vote_hashes[1]); + block = ledger.block (transaction, final_vote_hashes[1]); debug_assert (final_vote_hashes.size () == 2); } } @@ -223,7 +223,7 @@ std::pair>, std::vector>, std::vectorhead); auto hash = conf_info.height == 0 ? info->open_block : node.store.block.successor (transaction, conf_info.frontier); - auto block = node.store.block.get (transaction, hash); + auto block = node.ledger.block (transaction, hash); debug_assert (block != nullptr); if (node.ledger.dependents_confirmed (transaction, *block)) { diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index b238f38538..9ea31745d8 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -186,7 +186,7 @@ nano::vote_generator::~vote_generator () bool nano::vote_generator::should_vote (store::write_transaction const & transaction, nano::root const & root_a, nano::block_hash const & hash_a) { - auto block = ledger.store.block.get (transaction, hash_a); + auto block = ledger.block (transaction, hash_a); bool should_vote = false; if (is_final) { diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 7dd08665d1..e1c2d7a834 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -955,7 +955,7 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so if (status == 0) { nano::block_hash hash (result); - block = wallets.node.store.block.get (block_transaction, hash); + block = wallets.node.ledger.block (block_transaction, hash); if (block != nullptr) { cached_block = true; @@ -1199,7 +1199,7 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact } else if (!wallets.node.confirmation_height_processor.is_processing_block (hash)) { - auto block (wallets.node.store.block.get (block_transaction, hash)); + auto block = wallets.node.ledger.block (block_transaction, hash); if (block) { // Request confirmation for block which is not being processed yet diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 2b83d7d61a..99e47a3eb7 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -622,7 +622,7 @@ void nano_qt::history::refresh () for (auto i (0), n (tx_count->value ()); i < n && !hash.is_zero (); ++i) { QList items; - auto block (ledger.store.block.get (transaction, hash)); + auto block (ledger.block (transaction, hash)); if (block != nullptr) { block->visit (visitor); @@ -671,7 +671,7 @@ nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) : if (!hash_l.decode_hex (hash->text ().toStdString ())) { auto transaction (this->wallet.node.store.tx_begin_read ()); - auto block_l (this->wallet.node.store.block.get (transaction, hash_l)); + auto block_l (this->wallet.node.ledger.block (transaction, hash_l)); if (block_l != nullptr) { std::string contents; @@ -717,7 +717,7 @@ void nano_qt::block_viewer::rebroadcast_action (nano::block_hash const & hash_a) { auto done (true); auto transaction (wallet.node.ledger.store.tx_begin_read ()); - auto block (wallet.node.store.block.get (transaction, hash_a)); + auto block (wallet.node.ledger.block (transaction, hash_a)); if (block != nullptr) { wallet.node.network.flood_block (block); @@ -2299,7 +2299,7 @@ void nano_qt::block_creation::create_receive () { auto transaction (wallet.node.wallets.tx_begin_read ()); auto block_transaction (wallet.node.store.tx_begin_read ()); - auto block_l (wallet.node.store.block.get (block_transaction, source_l)); + auto block_l (wallet.node.ledger.block (block_transaction, source_l)); if (block_l != nullptr) { auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); @@ -2464,7 +2464,7 @@ void nano_qt::block_creation::create_open () { auto transaction (wallet.node.wallets.tx_begin_read ()); auto block_transaction (wallet.node.store.tx_begin_read ()); - auto block_l (wallet.node.store.block.get (block_transaction, source_l)); + auto block_l (wallet.node.ledger.block (block_transaction, source_l)); if (block_l != nullptr) { auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 4f1c158f98..569cdd8841 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -2395,7 +2395,7 @@ TEST (rpc, account_representative_set) wallet.insert_adhoc (key2.prv); auto key2_open_block_hash = wallet.send_sync (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ()); ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), key2_open_block_hash)); - auto key2_open_block = node->store.block.get (node->store.tx_begin_read (), key2_open_block_hash); + auto key2_open_block = node->ledger.block (node->store.tx_begin_read (), key2_open_block_hash); ASSERT_EQ (nano::dev::genesis_key.pub, key2_open_block->representative ()); // now change the representative of key2 to be genesis @@ -2412,7 +2412,7 @@ TEST (rpc, account_representative_set) nano::block_hash hash; ASSERT_FALSE (hash.decode_hex (block_text1)); ASSERT_FALSE (hash.is_zero ()); - auto block = node->store.block.get (node->store.tx_begin_read (), hash); + auto block = node->ledger.block (node->store.tx_begin_read (), hash); ASSERT_NE (block, nullptr); ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), hash)); ASSERT_EQ (key2.pub, block->representative ()); @@ -5228,7 +5228,7 @@ TEST (rpc, confirmation_height_currently_processing) std::shared_ptr frontier; { auto transaction = node->store.tx_begin_read (); - frontier = node->store.block.get (transaction, previous_genesis_chain_hash); + frontier = node->ledger.block (transaction, previous_genesis_chain_hash); } boost::property_tree::ptree request; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index dc2651b89a..a381a7a258 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -695,7 +695,7 @@ ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::store::write_ class representative_visitor final : public nano::block_visitor { public: - representative_visitor (nano::store::transaction const & transaction_a, nano::store::component & store_a); + representative_visitor (nano::store::transaction const & transaction_a, nano::ledger & ledger); ~representative_visitor () = default; void compute (nano::block_hash const & hash_a); void send_block (nano::send_block const & block_a) override; @@ -704,15 +704,15 @@ class representative_visitor final : public nano::block_visitor void change_block (nano::change_block const & block_a) override; void state_block (nano::state_block const & block_a) override; nano::store::transaction const & transaction; - nano::store::component & store; + nano::ledger & ledger; nano::block_hash current; nano::block_hash result; }; -representative_visitor::representative_visitor (nano::store::transaction const & transaction_a, nano::store::component & store_a) : - transaction (transaction_a), - store (store_a), - result (0) +representative_visitor::representative_visitor (nano::store::transaction const & transaction_a, nano::ledger & ledger) : + transaction{ transaction_a }, + ledger{ ledger }, + result{ 0 } { } @@ -721,9 +721,9 @@ void representative_visitor::compute (nano::block_hash const & hash_a) current = hash_a; while (result.is_zero ()) { - auto block (store.block.get (transaction, current)); - debug_assert (block != nullptr); - block->visit (*this); + auto block_l = ledger.block (transaction, current); + debug_assert (block_l != nullptr); + block_l->visit (*this); } } @@ -840,9 +840,9 @@ nano::uint128_t nano::ledger::balance (store::transaction const & transaction, n { return 0; } - auto block = store.block.get (transaction, hash); - debug_assert (block != nullptr); - return balance (*block); + auto block_l = block (transaction, hash); + debug_assert (block_l != nullptr); + return balance (*block_l); } nano::uint128_t nano::ledger::balance_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const @@ -860,6 +860,11 @@ nano::uint128_t nano::ledger::balance_safe (store::transaction const & transacti return result; } +std::shared_ptr nano::ledger::block (store::transaction const & transaction, nano::block_hash const & hash) const +{ + return store.block.get (transaction, hash); +} + // Balance for an account by account number nano::uint128_t nano::ledger::account_balance (store::transaction const & transaction_a, nano::account const & account_a, bool only_confirmed_a) { @@ -936,7 +941,7 @@ nano::block_hash nano::ledger::representative (store::transaction const & transa nano::block_hash nano::ledger::representative_calculated (store::transaction const & transaction_a, nano::block_hash const & hash_a) { - representative_visitor visitor (transaction_a, store); + representative_visitor visitor (transaction_a, *this); visitor.compute (hash_a); return visitor.result; } @@ -969,10 +974,10 @@ std::string nano::ledger::block_text (nano::block_hash const & hash_a) { std::string result; auto transaction (store.tx_begin_read ()); - auto block (store.block.get (transaction, hash_a)); - if (block != nullptr) + auto block_l = block (transaction, hash_a); + if (block_l != nullptr) { - block->serialize_json (result); + block_l->serialize_json (result); } return result; } @@ -1111,9 +1116,9 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan { auto info = account_info (transaction_a, account_l); debug_assert (info); - auto block (store.block.get (transaction_a, info->head)); - list_a.push_back (block); - block->visit (rollback); + auto block_l = block (transaction_a, info->head); + list_a.push_back (block_l); + block_l->visit (rollback); error = rollback.error; if (!error) { @@ -1148,9 +1153,9 @@ nano::account nano::ledger::account (nano::block const & block) const nano::account nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const { - auto block = store.block.get (transaction, hash); - debug_assert (block != nullptr); - return account (*block); + auto block_l = block (transaction, hash); + debug_assert (block_l != nullptr); + return account (*block_l); } nano::account nano::ledger::account_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const @@ -1161,10 +1166,10 @@ nano::account nano::ledger::account_safe (store::transaction const & transaction } else { - auto block (store.block.get (transaction_a, hash_a)); - if (block != nullptr) + auto block_l = block (transaction_a, hash_a); + if (block_l != nullptr) { - return account (*block); + return account (*block_l); } else { @@ -1176,10 +1181,10 @@ nano::account nano::ledger::account_safe (store::transaction const & transaction nano::account nano::ledger::account_safe (store::transaction const & transaction, nano::block_hash const & hash) const { - auto block = store.block.get (transaction, hash); - if (block) + auto block_l = block (transaction, hash); + if (block_l) { - return account (*block); + return account (*block_l); } else { @@ -1194,18 +1199,18 @@ std::optional nano::ledger::account_info (store::transaction nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a) { - auto block (store.block.get (transaction_a, hash_a)); + auto block_l = block (transaction_a, hash_a); auto block_balance (balance (transaction_a, hash_a)); - auto previous_balance (balance (transaction_a, block->previous ())); + auto previous_balance (balance (transaction_a, block_l->previous ())); return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; } nano::uint128_t nano::ledger::amount_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { - auto block (store.block.get (transaction_a, hash_a)); - debug_assert (block); + auto block_l = block (transaction_a, hash_a); + debug_assert (block_l); auto block_balance (balance (transaction_a, hash_a)); - auto previous_balance (balance_safe (transaction_a, block->previous (), error_a)); + auto previous_balance (balance_safe (transaction_a, block_l->previous (), error_a)); return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; } @@ -1237,10 +1242,10 @@ void nano::ledger::dump_account_chain (nano::account const & account_a, std::ost auto hash (latest (transaction, account_a)); while (!hash.is_zero ()) { - auto block (store.block.get (transaction, hash)); - debug_assert (block != nullptr); + auto block_l = block (transaction, hash); + debug_assert (block_l != nullptr); stream << hash.to_string () << std::endl; - hash = block->previous (); + hash = block_l->previous (); } } @@ -1328,7 +1333,7 @@ std::shared_ptr nano::ledger::find_receive_block_by_send_hash (stor { return nullptr; } - auto possible_receive_block = store.block.get (transaction, info.frontier); + auto possible_receive_block = block (transaction, info.frontier); // walk down the chain until the source field of a receive block matches the send block hash while (possible_receive_block != nullptr) @@ -1355,7 +1360,7 @@ std::shared_ptr nano::ledger::find_receive_block_by_send_hash (stor break; } - possible_receive_block = store.block.get (transaction, possible_receive_block->previous ()); + possible_receive_block = block (transaction, possible_receive_block->previous ()); } return result; @@ -1423,7 +1428,7 @@ std::shared_ptr nano::ledger::successor (store::transaction const & std::shared_ptr result; if (!successor.is_zero ()) { - result = store.block.get (transaction_a, successor); + result = block (transaction_a, successor); } debug_assert (successor.is_zero () || result != nullptr); return result; @@ -1434,12 +1439,12 @@ std::shared_ptr nano::ledger::forked_block (store::transaction cons debug_assert (!store.block.exists (transaction_a, block_a.hash ())); auto root (block_a.root ()); debug_assert (store.block.exists (transaction_a, root.as_block_hash ()) || store.account.exists (transaction_a, root.as_account ())); - auto result (store.block.get (transaction_a, store.block.successor (transaction_a, root.as_block_hash ()))); + auto result = block (transaction_a, store.block.successor (transaction_a, root.as_block_hash ())); if (result == nullptr) { auto info = account_info (transaction_a, root.as_account ()); debug_assert (info); - result = store.block.get (transaction_a, info->open_block); + result = block (transaction_a, info->open_block); debug_assert (result != nullptr); } return result; @@ -1450,7 +1455,7 @@ std::shared_ptr nano::ledger::head_block (store::transaction const auto info = store.account.get (transaction, account); if (info) { - return store.block.get (transaction, info->head); + return block (transaction, info->head); } return nullptr; } @@ -1461,12 +1466,12 @@ bool nano::ledger::block_confirmed (store::transaction const & transaction_a, na { return true; } - auto block = store.block.get (transaction_a, hash_a); - if (block) + auto block_l = block (transaction_a, hash_a); + if (block_l) { nano::confirmation_height_info confirmation_height_info; - store.confirmation_height.get (transaction_a, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); - auto confirmed (confirmation_height_info.height >= block->sideband ().height); + store.confirmation_height.get (transaction_a, block_l->account ().is_zero () ? block_l->sideband ().account : block_l->account (), confirmation_height_info); + auto confirmed (confirmation_height_info.height >= block_l->sideband ().height); return confirmed; } return false; @@ -1478,12 +1483,12 @@ uint64_t nano::ledger::pruning_action (store::write_transaction & transaction_a, nano::block_hash hash (hash_a); while (!hash.is_zero () && hash != constants.genesis->hash ()) { - auto block (store.block.get (transaction_a, hash)); - if (block != nullptr) + auto block_l = block (transaction_a, hash); + if (block_l != nullptr) { store.block.del (transaction_a, hash); store.pruned.put (transaction_a, hash); - hash = block->previous (); + hash = block_l->previous (); ++pruned_count; ++cache.pruned_count; if (pruned_count % batch_size_a == 0) @@ -1685,18 +1690,18 @@ nano::epoch nano::ledger::version (nano::block const & block) nano::epoch nano::ledger::version (store::transaction const & transaction, nano::block_hash const & hash) const { - auto block = store.block.get (transaction, hash); - if (block == nullptr) + auto block_l = block (transaction, hash); + if (block_l == nullptr) { return nano::epoch::epoch_0; } - return version (*block); + return version (*block_l); } uint64_t nano::ledger::height (store::transaction const & transaction, nano::block_hash const & hash) const { - auto block = store.block.get (transaction, hash); - return block->sideband ().height; + auto block_l = block (transaction, hash); + return block_l->sideband ().height; } nano::uncemented_info::uncemented_info (nano::block_hash const & cemented_frontier, nano::block_hash const & frontier, nano::account const & account) : diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index ac6206e6ea..d0d56ebb2f 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -51,6 +51,7 @@ class ledger final static nano::uint128_t balance (nano::block const & block); nano::uint128_t balance (store::transaction const &, nano::block_hash const &) const; nano::uint128_t balance_safe (store::transaction const &, nano::block_hash const &, bool &) const; + std::shared_ptr block (store::transaction const & transaction, nano::block_hash const & hash) const; nano::uint128_t account_balance (store::transaction const &, nano::account const &, bool = false); nano::uint128_t account_receivable (store::transaction const &, nano::account const &, bool = false); nano::uint128_t weight (nano::account const &); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 1dd982e004..b9b8e4ed40 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -100,7 +100,7 @@ TEST (system, receive_while_synchronizing) node1->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (200), ([&system, &key] () { auto hash (system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ())); auto transaction (system.nodes[0]->store.tx_begin_read ()); - auto block (system.nodes[0]->store.block.get (transaction, hash)); + auto block = system.nodes[0]->ledger.block (transaction, hash); std::string block_text; block->serialize_json (block_text); })); @@ -2162,7 +2162,7 @@ TEST (node, wallet_create_block_confirm_conflicts) // Call block confirm on the top level send block which will confirm everything underneath on both accounts. { - auto block = node->store.block.get (node->store.tx_begin_read (), latest); + auto block = node->ledger.block (node->store.tx_begin_read (), latest); node->scheduler.manual.push (block); std::shared_ptr election; ASSERT_TIMELY (10s, (election = node->active.election (block->qualified_root ())) != nullptr); diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 37e1376253..3ba0ce0009 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -416,7 +416,7 @@ void nano::test::system::generate_receive (nano::node & node_a) if (i != node_a.store.pending.end ()) { nano::pending_key const & send_hash (i->first); - send_block = node_a.store.block.get (transaction, send_hash.hash); + send_block = node_a.ledger.block (transaction, send_hash.hash); } } if (send_block != nullptr) From d68da31abc288c5c39a412568cbbcadbb7c4a641 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 5 Mar 2024 14:31:14 +0000 Subject: [PATCH 133/190] Reduce coupling to store.block.exists by using ledger::block_exists interface. --- nano/core_test/bootstrap.cpp | 10 ++-- nano/core_test/ledger.cpp | 54 ++++++++++----------- nano/core_test/node.cpp | 16 +++--- nano/core_test/wallet.cpp | 2 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 4 +- nano/node/bootstrap/bootstrap_server.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 2 +- nano/node/json_handler.cpp | 10 ++-- nano/qt/qt.cpp | 2 +- nano/qt_test/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 14 +++--- nano/secure/ledger.cpp | 27 ++++++----- nano/secure/ledger.hpp | 1 + 14 files changed, 77 insertions(+), 71 deletions(-) diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index bf1045d118..d1fbbb375a 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -659,13 +659,13 @@ TEST (bootstrap_processor, push_diamond_pruning) auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 2)); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, open->hash (), 1)); - ASSERT_TRUE (node1->store.block.exists (transaction, nano::dev::genesis->hash ())); - ASSERT_FALSE (node1->store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (node1->ledger.block_exists (transaction, nano::dev::genesis->hash ())); + ASSERT_FALSE (node1->ledger.block_exists (transaction, send1->hash ())); ASSERT_TRUE (node1->store.pruned.exists (transaction, send1->hash ())); - ASSERT_FALSE (node1->store.block.exists (transaction, open->hash ())); + ASSERT_FALSE (node1->ledger.block_exists (transaction, open->hash ())); ASSERT_TRUE (node1->store.pruned.exists (transaction, open->hash ())); - ASSERT_TRUE (node1->store.block.exists (transaction, send2->hash ())); - ASSERT_TRUE (node1->store.block.exists (transaction, receive->hash ())); + ASSERT_TRUE (node1->ledger.block_exists (transaction, send2->hash ())); + ASSERT_TRUE (node1->ledger.block_exists (transaction, receive->hash ())); ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (5, node1->ledger.cache.block_count); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 1436e3006f..eb29e207d6 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2382,7 +2382,7 @@ TEST (ledger, state_send_receive) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2405,7 +2405,7 @@ TEST (ledger, state_send_receive) .work (*pool.generate (send1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, receive1->hash ())); auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); @@ -2437,7 +2437,7 @@ TEST (ledger, state_receive) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2455,7 +2455,7 @@ TEST (ledger, state_receive) .work (*pool.generate (send1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, receive1->hash ())); auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); @@ -2488,7 +2488,7 @@ TEST (ledger, state_rep_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); - ASSERT_TRUE (store.block.exists (transaction, change1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, change1->hash ())); auto change2 = ledger.block (transaction, change1->hash ()); ASSERT_NE (nullptr, change2); ASSERT_EQ (*change1, *change2); @@ -2522,7 +2522,7 @@ TEST (ledger, state_open) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2542,7 +2542,7 @@ TEST (ledger, state_open) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); - ASSERT_TRUE (store.block.exists (transaction, open1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, open1->hash ())); auto open2 = ledger.block (transaction, open1->hash ()); ASSERT_NE (nullptr, open2); ASSERT_EQ (*open1, *open2); @@ -2665,7 +2665,7 @@ TEST (ledger, state_unreceivable_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2702,7 +2702,7 @@ TEST (ledger, state_receive_bad_amount_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2774,7 +2774,7 @@ TEST (ledger, state_receive_wrong_account_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -2968,7 +2968,7 @@ TEST (ledger, state_send_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -3001,7 +3001,7 @@ TEST (ledger, state_receive_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -3020,7 +3020,7 @@ TEST (ledger, state_receive_change) .work (*pool.generate (send1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, receive1->hash ())); auto receive2 = ledger.block (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); ASSERT_EQ (*receive1, *receive2); @@ -3140,7 +3140,7 @@ TEST (ledger, state_rollback_send) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (ledger.block_exists (transaction, send1->hash ())); auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); @@ -3151,7 +3151,7 @@ TEST (ledger, state_rollback_send) ASSERT_EQ (nano::dev::genesis->account (), info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); @@ -3195,7 +3195,7 @@ TEST (ledger, state_rollback_receive) ASSERT_TRUE (info); ASSERT_EQ (nano::dev::genesis->account (), info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); - ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); @@ -3235,8 +3235,8 @@ TEST (ledger, state_rollback_received_send) ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); - ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); @@ -3265,7 +3265,7 @@ TEST (ledger, state_rep_change_rollback) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, change1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, change1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); @@ -3303,7 +3303,7 @@ TEST (ledger, state_open_rollback) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, open1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, open1->hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); auto info = ledger.pending_info (transaction, nano::pending_key (destination.pub, send1->hash ())); @@ -3334,7 +3334,7 @@ TEST (ledger, state_send_change_rollback) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); @@ -3373,7 +3373,7 @@ TEST (ledger, state_receive_change_rollback) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); - ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); + ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); @@ -4206,7 +4206,7 @@ TEST (ledger, unchecked_epoch) } node1.block_processor.add (send1); node1.block_processor.add (open1); - ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), epoch1->hash ())); + ASSERT_TIMELY (5s, node1.ledger.block_exists (node1.store.tx_begin_read (), epoch1->hash ())); { // Waits for the last blocks to pass through block_processor and unchecked.put queues ASSERT_TIMELY_EQ (10s, 0, node1.unchecked.count ()); @@ -4281,10 +4281,10 @@ TEST (ledger, unchecked_epoch_invalid) node1.block_processor.add (send1); node1.block_processor.add (open1); // Waits for the last blocks to pass through block_processor and unchecked.put queues - ASSERT_TIMELY (10s, node1.store.block.exists (node1.store.tx_begin_read (), epoch2->hash ())); + ASSERT_TIMELY (10s, node1.ledger.block_exists (node1.store.tx_begin_read (), epoch2->hash ())); { auto transaction = node1.store.tx_begin_read (); - ASSERT_FALSE (node1.store.block.exists (transaction, epoch1->hash ())); + ASSERT_FALSE (node1.ledger.block_exists (transaction, epoch1->hash ())); auto unchecked_count = node1.unchecked.count (); ASSERT_EQ (unchecked_count, 0); ASSERT_EQ (unchecked_count, node1.unchecked.count ()); @@ -4348,7 +4348,7 @@ TEST (ledger, unchecked_open) } node1.block_processor.add (send1); // Waits for the send1 block to pass through block_processor and unchecked.put queues - ASSERT_TIMELY (5s, node1.store.block.exists (node1.store.tx_begin_read (), open1->hash ())); + ASSERT_TIMELY (5s, node1.ledger.block_exists (node1.store.tx_begin_read (), open1->hash ())); ASSERT_EQ (0, node1.unchecked.count ()); } @@ -4419,7 +4419,7 @@ TEST (ledger, unchecked_receive) ASSERT_EQ (blocks.size (), 1); } node1.block_processor.add (send2); - ASSERT_TIMELY (10s, node1.store.block.exists (node1.store.tx_begin_read (), receive1->hash ())); + ASSERT_TIMELY (10s, node1.ledger.block_exists (node1.store.tx_begin_read (), receive1->hash ())); ASSERT_EQ (0, node1.unchecked.count ()); } diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 35c06a9cfa..fa999b31bc 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -668,8 +668,8 @@ TEST (node, fork_keep) auto winner (*election1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); - ASSERT_TRUE (node1.store.block.exists (transaction0, send1->hash ())); - ASSERT_TRUE (node2.store.block.exists (transaction1, send1->hash ())); + ASSERT_TRUE (node1.ledger.block_exists (transaction0, send1->hash ())); + ASSERT_TRUE (node2.ledger.block_exists (transaction1, send1->hash ())); } TEST (node, fork_flip) @@ -811,7 +811,7 @@ TEST (node, fork_bootstrap_flip) // Insert but don't rebroadcast, simulating settled blocks ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send2)); - ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); + ASSERT_TRUE (node2.ledger.block_exists (node2.store.tx_begin_read (), send2->hash ())); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block auto again (true); system0.deadline_set (50s); @@ -820,7 +820,7 @@ TEST (node, fork_bootstrap_flip) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); - again = !node2.store.block.exists (node2.store.tx_begin_read (), send1->hash ()); + again = !node2.ledger.block_exists (node2.store.tx_begin_read (), send1->hash ()); } } @@ -972,9 +972,9 @@ TEST (node, fork_open_flip) // check the correct blocks are in the ledgers auto transaction1 (node1.store.tx_begin_read ()); auto transaction2 (node2.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block.exists (transaction1, open1->hash ())); - ASSERT_TRUE (node2.store.block.exists (transaction2, open1->hash ())); - ASSERT_FALSE (node2.store.block.exists (transaction2, open2->hash ())); + ASSERT_TRUE (node1.ledger.block_exists (transaction1, open1->hash ())); + ASSERT_TRUE (node2.ledger.block_exists (transaction2, open1->hash ())); + ASSERT_FALSE (node2.ledger.block_exists (transaction2, open2->hash ())); } TEST (node, coherent_observer) @@ -983,7 +983,7 @@ TEST (node, coherent_observer) auto & node1 (*system.nodes[0]); node1.observers.blocks.add ([&node1] (nano::election_status const & status_a, std::vector const &, nano::account const &, nano::uint128_t const &, bool, bool) { auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block.exists (transaction, status_a.winner->hash ())); + ASSERT_TRUE (node1.ledger.block_exists (transaction, status_a.winner->hash ())); }); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index cbfa73eb9d..3c9802c633 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1223,7 +1223,7 @@ TEST (wallet, receive_pruned) } ASSERT_EQ (1, node2.ledger.cache.pruned_count); ASSERT_TRUE (node2.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_FALSE (node2.store.block.exists (node2.store.tx_begin_read (), send1->hash ())); + ASSERT_FALSE (node2.ledger.block_exists (node2.store.tx_begin_read (), send1->hash ())); wallet2.insert_adhoc (key.prv, false); diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 2fcd9653a2..276e64418c 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -363,14 +363,14 @@ void nano::bulk_pull_server::set_current_end () include_start = false; debug_assert (request != nullptr); auto transaction (node->store.tx_begin_read ()); - if (!node->store.block.exists (transaction, request->end)) + if (!node->ledger.block_exists (transaction, request->end)) { node->logger.debug (nano::log::type::bulk_pull_server, "Bulk pull end block doesn't exist: {}, sending everything", request->end.to_string ()); request->end.clear (); } - if (node->store.block.exists (transaction, request->start.as_block_hash ())) + if (node->ledger.block_exists (transaction, request->start.as_block_hash ())) { node->logger.debug (nano::log::type::bulk_pull_server, "Bulk pull request for block hash: {}", request->start.to_string ()); diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 258eb4e883..5585212fd8 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -192,7 +192,7 @@ nano::asc_pull_ack nano::bootstrap_server::process (store::transaction const & t { case asc_pull_req::hash_type::block: { - if (store.block.exists (transaction, request.start.as_block_hash ())) + if (ledger.block_exists (transaction, request.start.as_block_hash ())) { return prepare_response (transaction, id, request.start.as_block_hash (), count); } diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index f2ed6623ac..26cc21b42c 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -262,7 +262,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & source = block->link ().as_block_hash (); } - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block.exists (transaction_a, source)) + if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { hit_receive = true; reached_target = true; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index e99766d1ba..18c1e0dc28 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -221,7 +221,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source source = block->link ().as_block_hash (); } - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block.exists (transaction_a, source)) + if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { if (!hit_receive && !block_callback_data_a.empty ()) { diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index d50bacdd16..3ef09287ad 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1432,7 +1432,7 @@ void nano::json_handler::block_account () if (!ec) { auto transaction (node.store.tx_begin_read ()); - if (node.store.block.exists (transaction, hash)) + if (node.ledger.block_exists (transaction, hash)) { auto account (node.ledger.account (transaction, hash)); response_l.put ("account", account.to_account ()); @@ -1652,7 +1652,7 @@ void nano::json_handler::block_create () else if (previous_text.is_initialized () && balance_text.is_initialized () && type == "send") { auto transaction (node.store.tx_begin_read ()); - if (node.store.block.exists (transaction, previous) && node.ledger.balance (transaction, previous) != balance.number ()) + if (node.ledger.block_exists (transaction, previous) && node.ledger.balance (transaction, previous) != balance.number ()) { ec = nano::error_rpc::block_create_balance_mismatch; } @@ -2605,7 +2605,7 @@ void nano::json_handler::account_history () { if (!hash.decode_hex (*head_str)) { - if (node.store.block.exists (transaction, hash)) + if (node.ledger.block_exists (transaction, hash)) { account = node.ledger.account (transaction, hash); } @@ -3198,7 +3198,7 @@ void nano::json_handler::process () { std::shared_ptr block_state (std::static_pointer_cast (block)); auto transaction (rpc_l->node.store.tx_begin_read ()); - if (!block_state->hashables.previous.is_zero () && !rpc_l->node.store.block.exists (transaction, block_state->hashables.previous)) + if (!block_state->hashables.previous.is_zero () && !rpc_l->node.ledger.block_exists (transaction, block_state->hashables.previous)) { rpc_l->ec = nano::error_process::gap_previous; } @@ -5093,7 +5093,7 @@ void nano::json_handler::work_generate () { // Fetch account from block if not given auto transaction_l (node.store.tx_begin_read ()); - if (node.store.block.exists (transaction_l, hash)) + if (node.ledger.block_exists (transaction_l, hash)) { account = node.ledger.account (transaction_l, hash); } diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 99e47a3eb7..efd112cd7b 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -696,7 +696,7 @@ nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) : if (!error) { auto transaction (this->wallet.node.store.tx_begin_read ()); - if (this->wallet.node.store.block.exists (transaction, block)) + if (this->wallet.node.ledger.block_exists (transaction, block)) { rebroadcast->setEnabled (false); this->wallet.node.background ([this, block] () { diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 3a6d9b4dc1..3f1972bd16 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -389,7 +389,7 @@ TEST (wallet, DISABLED_process_block) { auto transaction (system.nodes[0]->store.tx_begin_read ()); system.deadline_set (10s); - while (system.nodes[0]->store.block.exists (transaction, send.hash ())) + while (system.nodes[0]->ledger.block_exists (transaction, send.hash ())) { ASSERT_NO_ERROR (system.poll ()); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 569cdd8841..32e8a12d35 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -4292,7 +4292,7 @@ TEST (rpc, block_info_pruning) { auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 1)); - ASSERT_TRUE (node1->store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (node1->ledger.block_exists (transaction, receive1->hash ())); } auto const rpc_ctx = add_rpc (system, node1); // Pruned block @@ -4358,7 +4358,7 @@ TEST (rpc, pruned_exists) { auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 1)); - ASSERT_TRUE (node1->store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (node1->ledger.block_exists (transaction, receive1->hash ())); } auto const rpc_ctx = add_rpc (system, node1); // Pruned block @@ -6558,7 +6558,7 @@ TEST (rpc, receive_unopened) auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub)); - ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ())); + ASSERT_TRUE (node->ledger.block_exists (node->store.tx_begin_read (), send1->hash ())); wallet->insert_adhoc (key1.prv); // should not auto receive, amount sent was lower than minimum auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -6582,7 +6582,7 @@ TEST (rpc, receive_unopened) auto send2 (wallet->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (send1->hash ()))); ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != prev_amount); ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key2.pub)); - ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send2->hash ())); + ASSERT_TRUE (node->ledger.block_exists (node->store.tx_begin_read (), send2->hash ())); nano::public_key rep; wallet->store.representative_set (node->wallets.tx_begin_write (), rep); wallet->insert_adhoc (key2.prv); // should not auto receive, amount sent was lower than minimum @@ -6617,7 +6617,7 @@ TEST (rpc, receive_work_disabled) ASSERT_NE (send1, nullptr); ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub)); - ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ())); + ASSERT_TRUE (node->ledger.block_exists (node->store.tx_begin_read (), send1->hash ())); wallet->insert_adhoc (key1.prv); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -6662,9 +6662,9 @@ TEST (rpc, receive_pruned) } ASSERT_EQ (2, node2->ledger.cache.pruned_count); ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_FALSE (node2->store.block.exists (node2->store.tx_begin_read (), send1->hash ())); + ASSERT_FALSE (node2->ledger.block_exists (node2->store.tx_begin_read (), send1->hash ())); ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_FALSE (node2->store.block.exists (node2->store.tx_begin_read (), send2->hash ())); + ASSERT_FALSE (node2->ledger.block_exists (node2->store.tx_begin_read (), send2->hash ())); ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send3->hash ())); auto const rpc_ctx = add_rpc (system, node2); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index a381a7a258..d7464f4e07 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -848,7 +848,7 @@ nano::uint128_t nano::ledger::balance (store::transaction const & transaction, n nano::uint128_t nano::ledger::balance_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { nano::uint128_t result (0); - if (pruning && !hash_a.is_zero () && !store.block.exists (transaction_a, hash_a)) + if (pruning && !hash_a.is_zero () && !block_exists (transaction_a, hash_a)) { error_a = true; result = 0; @@ -865,6 +865,11 @@ std::shared_ptr nano::ledger::block (store::transaction const & tra return store.block.get (transaction, hash); } +bool nano::ledger::block_exists (store::transaction const & transaction, nano::block_hash const & hash) const +{ + return store.block.exists (transaction, hash); +} + // Balance for an account by account number nano::uint128_t nano::ledger::account_balance (store::transaction const & transaction_a, nano::account const & account_a, bool only_confirmed_a) { @@ -935,7 +940,7 @@ nano::block_status nano::ledger::process (store::write_transaction const & trans nano::block_hash nano::ledger::representative (store::transaction const & transaction_a, nano::block_hash const & hash_a) { auto result (representative_calculated (transaction_a, hash_a)); - debug_assert (result.is_zero () || store.block.exists (transaction_a, result)); + debug_assert (result.is_zero () || block_exists (transaction_a, result)); return result; } @@ -957,12 +962,12 @@ bool nano::ledger::block_or_pruned_exists (store::transaction const & transactio { return true; } - return store.block.exists (transaction_a, hash_a); + return block_exists (transaction_a, hash_a); } bool nano::ledger::root_exists (store::transaction const & transaction_a, nano::root const & root_a) { - return store.block.exists (transaction_a, root_a.as_block_hash ()) || store.account.exists (transaction_a, root_a.as_account ()); + return block_exists (transaction_a, root_a.as_block_hash ()) || store.account.exists (transaction_a, root_a.as_account ()); } std::string nano::ledger::block_text (char const * hash_a) @@ -994,7 +999,7 @@ bool nano::ledger::is_send (store::transaction const & transaction_a, nano::bloc * requires that the previous block exists in the database. * This is because it must retrieve the balance of the previous block. */ - debug_assert (block_a.has_sideband () || previous.is_zero () || store.block.exists (transaction_a, previous)); + debug_assert (block_a.has_sideband () || previous.is_zero () || block_exists (transaction_a, previous)); bool result (false); if (block_a.has_sideband ()) @@ -1037,7 +1042,7 @@ nano::block_hash nano::ledger::block_source (store::transaction const & transact * passed in exist in the database. This is because it will try * to check account balances to determine if it is a send block. */ - debug_assert (block_a.previous ().is_zero () || store.block.exists (transaction_a, block_a.previous ())); + debug_assert (block_a.previous ().is_zero () || 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. @@ -1103,12 +1108,12 @@ 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 (store::write_transaction const & transaction_a, nano::block_hash const & block_a, std::vector> & list_a) { - debug_assert (store.block.exists (transaction_a, block_a)); + debug_assert (block_exists (transaction_a, block_a)); auto account_l (account (transaction_a, block_a)); auto block_account_height (height (transaction_a, block_a)); rollback_visitor rollback (transaction_a, *this, list_a); auto error (false); - while (!error && store.block.exists (transaction_a, block_a)) + while (!error && block_exists (transaction_a, block_a)) { nano::confirmation_height_info confirmation_height_info; store.confirmation_height.get (transaction_a, account_l, confirmation_height_info); @@ -1301,7 +1306,7 @@ class dependent_block_visitor : public nano::block_visitor result[0] = block_a.hashables.previous; result[1] = block_a.hashables.link.as_block_hash (); // ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped - if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block.exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a))) + if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a))) { result[1].clear (); } @@ -1436,9 +1441,9 @@ std::shared_ptr nano::ledger::successor (store::transaction const & std::shared_ptr nano::ledger::forked_block (store::transaction const & transaction_a, nano::block const & block_a) { - debug_assert (!store.block.exists (transaction_a, block_a.hash ())); + debug_assert (!block_exists (transaction_a, block_a.hash ())); auto root (block_a.root ()); - debug_assert (store.block.exists (transaction_a, root.as_block_hash ()) || store.account.exists (transaction_a, root.as_account ())); + debug_assert (block_exists (transaction_a, root.as_block_hash ()) || store.account.exists (transaction_a, root.as_account ())); auto result = block (transaction_a, store.block.successor (transaction_a, root.as_block_hash ())); if (result == nullptr) { diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index d0d56ebb2f..52accb506c 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -52,6 +52,7 @@ class ledger final nano::uint128_t balance (store::transaction const &, nano::block_hash const &) const; nano::uint128_t balance_safe (store::transaction const &, nano::block_hash const &, bool &) const; std::shared_ptr block (store::transaction const & transaction, nano::block_hash const & hash) const; + bool block_exists (store::transaction const & transaction, nano::block_hash const & hash) const; nano::uint128_t account_balance (store::transaction const &, nano::account const &, bool = false); nano::uint128_t account_receivable (store::transaction const &, nano::account const &, bool = false); nano::uint128_t weight (nano::account const &); From 5f28f1a8b84c4d9c85c42428cef96407e19feb45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Tue, 5 Mar 2024 18:42:20 +0100 Subject: [PATCH 134/190] Local block broadcaster (#4454) * Add rolled back event * Local block broadcaster * Rate limit block broadcasting * Rename to `local_block_broadcaster` * Node initialization order * Fix tests * Bump local block queue size to 8k elements --- nano/lib/stats_enums.hpp | 8 ++ nano/lib/thread_roles.cpp | 3 + nano/lib/thread_roles.hpp | 1 + nano/node/CMakeLists.txt | 4 +- nano/node/block_broadcast.cpp | 51 -------- nano/node/block_broadcast.hpp | 28 ----- nano/node/blockprocessor.cpp | 4 + nano/node/blockprocessor.hpp | 1 + nano/node/local_block_broadcaster.cpp | 170 ++++++++++++++++++++++++++ nano/node/local_block_broadcaster.hpp | 106 ++++++++++++++++ nano/node/node.cpp | 10 +- nano/node/node.hpp | 4 +- nano/rpc_test/rpc.cpp | 4 +- 13 files changed, 305 insertions(+), 89 deletions(-) delete mode 100644 nano/node/block_broadcast.cpp delete mode 100644 nano/node/block_broadcast.hpp create mode 100644 nano/node/local_block_broadcaster.cpp create mode 100644 nano/node/local_block_broadcaster.hpp diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 63c90bddc5..5150d7dec0 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -49,6 +49,7 @@ enum class type : uint8_t election_scheduler, optimistic_scheduler, handshake, + local_block_broadcaster, bootstrap_ascending, bootstrap_ascending_accounts, @@ -102,6 +103,7 @@ enum class detail : uint8_t old, gap_previous, gap_source, + rollback, rollback_failed, progress, bad_signature, @@ -328,6 +330,12 @@ enum class detail : uint8_t deprioritize, deprioritize_failed, + // block broadcaster + broadcast_normal, + broadcast_aggressive, + erase_old, + erase_confirmed, + _last // Must be the last enum }; diff --git a/nano/lib/thread_roles.cpp b/nano/lib/thread_roles.cpp index 0824d23733..99caa097fe 100644 --- a/nano/lib/thread_roles.cpp +++ b/nano/lib/thread_roles.cpp @@ -100,6 +100,9 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) case nano::thread_role::name::scheduler_priority: thread_role_name_string = "Sched Priority"; break; + case nano::thread_role::name::local_block_broadcasting: + thread_role_name_string = "Local broadcast"; + break; default: debug_assert (false && "nano::thread_role::get_string unhandled thread role"); } diff --git a/nano/lib/thread_roles.hpp b/nano/lib/thread_roles.hpp index 311ae58d1b..56848761ce 100644 --- a/nano/lib/thread_roles.hpp +++ b/nano/lib/thread_roles.hpp @@ -42,6 +42,7 @@ enum class name scheduler_manual, scheduler_optimistic, scheduler_priority, + local_block_broadcasting, }; /* diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 4452df575c..d25585ff44 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -20,8 +20,6 @@ add_library( backlog_population.cpp bandwidth_limiter.hpp bandwidth_limiter.cpp - block_broadcast.cpp - block_broadcast.hpp blockprocessor.hpp blockprocessor.cpp bootstrap/block_deserializer.hpp @@ -100,6 +98,8 @@ add_library( ipc/ipc_server.cpp json_handler.hpp json_handler.cpp + local_block_broadcaster.cpp + local_block_broadcaster.hpp make_store.hpp make_store.cpp network.hpp diff --git a/nano/node/block_broadcast.cpp b/nano/node/block_broadcast.cpp deleted file mode 100644 index 898a607f23..0000000000 --- a/nano/node/block_broadcast.cpp +++ /dev/null @@ -1,51 +0,0 @@ -#include -#include -#include - -nano::block_broadcast::block_broadcast (nano::network & network, bool enabled) : - network{ network }, - enabled{ enabled } -{ -} - -void nano::block_broadcast::connect (nano::block_processor & block_processor) -{ - if (!enabled) - { - return; - } - block_processor.block_processed.add ([this] (auto const & result, auto const & context) { - switch (result) - { - case nano::block_status::progress: - observe (context); - break; - default: - break; - } - }); -} - -void nano::block_broadcast::observe (nano::block_processor::context const & context) -{ - auto const & block = context.block; - if (context.source == nano::block_source::local) - { - // Block created on this node - // Perform more agressive initial flooding - network.flood_block_initial (block); - } - else - { - if (context.source != nano::block_source::bootstrap && context.source != nano::block_source::bootstrap_legacy) - { - // Block arrived from realtime traffic, do normal gossip. - network.flood_block (block, nano::transport::buffer_drop_policy::limiter); - } - else - { - // Block arrived from bootstrap - // Don't broadcast blocks we're bootstrapping - } - } -} diff --git a/nano/node/block_broadcast.hpp b/nano/node/block_broadcast.hpp deleted file mode 100644 index 0f0ee62ff2..0000000000 --- a/nano/node/block_broadcast.hpp +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#include -#include - -#include -#include - -namespace nano -{ -class network; - -// This class tracks blocks that originated from this node. -class block_broadcast -{ -public: - block_broadcast (nano::network & network, bool enabled = false); - // Add batch_processed observer to block_processor if enabled - void connect (nano::block_processor & block_processor); - -private: - // Block_processor observer - void observe (nano::block_processor::context const &); - - nano::network & network; - bool enabled; -}; -} diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index f9e2430e02..24ed806777 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -152,11 +152,15 @@ void nano::block_processor::rollback_competitor (store::write_transaction const } else { + node.stats.inc (nano::stat::type::ledger, nano::stat::detail::rollback); node.logger.debug (nano::log::type::blockprocessor, "Blocks rolled back: {}", rollback_list.size ()); } + // Deleting from votes cache, stop active transaction for (auto & i : rollback_list) { + rolled_back.notify (i); + node.history.erase (i->root ()); // Stop all rolled back active transactions except initial if (i->hash () != successor->hash ()) diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index ee5f4219d0..3cc7663c21 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -86,6 +86,7 @@ class block_processor final // The batch observer feeds the processed observer nano::observer_set block_processed; nano::observer_set batch_processed; + nano::observer_set const &> rolled_back; private: // Roll back block in the ledger that conflicts with 'block' diff --git a/nano/node/local_block_broadcaster.cpp b/nano/node/local_block_broadcaster.cpp new file mode 100644 index 0000000000..0e5097e59e --- /dev/null +++ b/nano/node/local_block_broadcaster.cpp @@ -0,0 +1,170 @@ +#include +#include +#include +#include +#include +#include + +nano::local_block_broadcaster::local_block_broadcaster (nano::node & node_a, nano::block_processor & block_processor_a, nano::network & network_a, nano::stats & stats_a, bool enabled_a) : + node{ node_a }, + block_processor{ block_processor_a }, + network{ network_a }, + stats{ stats_a }, + enabled{ enabled_a } +{ + if (!enabled) + { + return; + } + + block_processor.batch_processed.add ([this] (auto const & batch) { + bool should_notify = false; + for (auto const & [result, context] : batch) + { + // Only rebroadcast local blocks that were successfully processed (no forks or gaps) + if (result == nano::block_status::progress && context.source == nano::block_source::local) + { + nano::lock_guard guard{ mutex }; + local_blocks.emplace_back (local_entry{ context.block, std::chrono::steady_clock::now () }); + stats.inc (nano::stat::type::local_block_broadcaster, nano::stat::detail::insert); + should_notify = true; + } + } + if (should_notify) + { + condition.notify_all (); + } + }); + + block_processor.rolled_back.add ([this] (auto const & block) { + nano::lock_guard guard{ mutex }; + auto erased = local_blocks.get ().erase (block->hash ()); + stats.add (nano::stat::type::local_block_broadcaster, nano::stat::detail::rollback, nano::stat::dir::in, erased); + }); +} + +nano::local_block_broadcaster::~local_block_broadcaster () +{ + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); +} + +void nano::local_block_broadcaster::start () +{ + if (!enabled) + { + return; + } + + debug_assert (!thread.joinable ()); + + thread = std::thread{ [this] () { + nano::thread_role::set (nano::thread_role::name::local_block_broadcasting); + run (); + } }; +} + +void nano::local_block_broadcaster::stop () +{ + { + nano::lock_guard lock{ mutex }; + stopped = true; + } + condition.notify_all (); + nano::join_or_pass (thread); +} + +void nano::local_block_broadcaster::run () +{ + nano::unique_lock lock{ mutex }; + while (!stopped) + { + stats.inc (nano::stat::type::local_block_broadcaster, nano::stat::detail::loop); + + condition.wait_for (lock, check_interval); + debug_assert ((std::this_thread::yield (), true)); // Introduce some random delay in debug builds + + if (!stopped) + { + cleanup (); + run_broadcasts (lock); + debug_assert (lock.owns_lock ()); + } + } +} + +void nano::local_block_broadcaster::run_broadcasts (nano::unique_lock & lock) +{ + debug_assert (lock.owns_lock ()); + + std::vector> to_broadcast; + + auto const now = std::chrono::steady_clock::now (); + for (auto & entry : local_blocks) + { + if (elapsed (entry.last_broadcast, broadcast_interval, now)) + { + entry.last_broadcast = now; + to_broadcast.push_back (entry.block); + } + } + + lock.unlock (); + + for (auto const & block : to_broadcast) + { + while (!limiter.should_pass (1)) + { + std::this_thread::sleep_for (std::chrono::milliseconds{ 100 }); + if (stopped) + { + return; + } + } + + stats.inc (nano::stat::type::local_block_broadcaster, nano::stat::detail::broadcast, nano::stat::dir::out); + + network.flood_block_initial (block); + } + + lock.lock (); +} + +void nano::local_block_broadcaster::cleanup () +{ + debug_assert (!mutex.try_lock ()); + + // Erase oldest blocks if the queue gets too big + while (local_blocks.size () > max_size) + { + stats.inc (nano::stat::type::local_block_broadcaster, nano::stat::detail::erase_oldest); + local_blocks.pop_front (); + } + + // TODO: Mutex is held during IO, but it should be fine since it's not performance critical + auto transaction = node.store.tx_begin_read (); + erase_if (local_blocks, [this, &transaction] (auto const & entry) { + transaction.refresh_if_needed (); + + if (entry.last_broadcast == std::chrono::steady_clock::time_point{}) + { + // This block has never been broadcasted, keep it so it's broadcasted at least once + return false; + } + if (node.block_confirmed_or_being_confirmed (transaction, entry.block->hash ())) + { + stats.inc (nano::stat::type::local_block_broadcaster, nano::stat::detail::erase_confirmed); + return true; + } + return false; + }); +} + +std::unique_ptr nano::local_block_broadcaster::collect_container_info (const std::string & name) const +{ + nano::lock_guard guard{ mutex }; + + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (container_info{ "local", local_blocks.size (), sizeof (decltype (local_blocks)::value_type) })); + return composite; +} \ No newline at end of file diff --git a/nano/node/local_block_broadcaster.hpp b/nano/node/local_block_broadcaster.hpp new file mode 100644 index 0000000000..486fe85512 --- /dev/null +++ b/nano/node/local_block_broadcaster.hpp @@ -0,0 +1,106 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace mi = boost::multi_index; + +namespace nano +{ +class node; +class network; +} + +namespace nano +{ +/** + * Broadcasts blocks to the network + * Tracks local blocks for more aggressive propagation + */ +class local_block_broadcaster +{ + enum class broadcast_strategy + { + normal, + aggressive, + }; + +public: + local_block_broadcaster (nano::node &, nano::block_processor &, nano::network &, nano::stats &, bool enabled = false); + ~local_block_broadcaster (); + + void start (); + void stop (); + + std::unique_ptr collect_container_info (std::string const & name) const; + +private: + void run (); + void run_broadcasts (nano::unique_lock &); + void cleanup (); + +private: // Dependencies + nano::node & node; + nano::block_processor & block_processor; + nano::network & network; + nano::stats & stats; + +private: + struct local_entry + { + std::shared_ptr const block; + std::chrono::steady_clock::time_point const arrival; + mutable std::chrono::steady_clock::time_point last_broadcast{}; // Not part of any index + + nano::block_hash hash () const + { + return block->hash (); + } + }; + + // clang-format off + class tag_sequenced {}; + class tag_hash {}; + + using ordered_locals = boost::multi_index_container>, + mi::hashed_unique, + mi::const_mem_fun> + >>; + // clang-format on + + ordered_locals local_blocks; + +private: + bool enabled{ false }; + + nano::bandwidth_limiter limiter{ broadcast_rate_limit, broadcast_rate_burst_ratio }; + + std::atomic stopped{ false }; + nano::condition_variable condition; + mutable nano::mutex mutex; + std::thread thread; + + // TODO: Make these configurable + static std::size_t constexpr max_size{ 1024 * 8 }; + static std::chrono::seconds constexpr check_interval{ 30 }; + static std::chrono::seconds constexpr broadcast_interval{ 60 }; + static std::size_t constexpr broadcast_rate_limit{ 32 }; + static double constexpr broadcast_rate_burst_ratio{ 3 }; +}; +} diff --git a/nano/node/node.cpp b/nano/node/node.cpp index ac5f56b2c9..a76d010e3b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -195,14 +195,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons ascendboot{ config, block_processor, ledger, network, stats }, websocket{ config.websocket_config, observers, wallets, ledger, io_ctx, logger }, epoch_upgrader{ *this, ledger, store, network_params, logger }, + local_block_broadcaster{ *this, block_processor, network, stats, !flags.disable_block_processor_republishing }, + process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket }, startup_time (std::chrono::steady_clock::now ()), - node_seq (seq), - block_broadcast{ network, !flags.disable_block_processor_republishing }, - process_live_dispatcher{ ledger, scheduler.priority, vote_cache, websocket } + node_seq (seq) { logger.debug (nano::log::type::node, "Constructing node..."); - block_broadcast.connect (block_processor); process_live_dispatcher.connect (block_processor); unchecked.satisfied.add ([this] (nano::unchecked_info const & info) { @@ -551,6 +550,7 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (collect_container_info (node.final_generator, "vote_generator_final")); composite->add_component (node.ascendboot.collect_container_info ("bootstrap_ascending")); composite->add_component (node.unchecked.collect_container_info ("unchecked")); + composite->add_component (node.local_block_broadcaster.collect_container_info ("local_block_broadcaster")); return composite; } @@ -659,6 +659,7 @@ void nano::node::start () } websocket.start (); telemetry.start (); + local_block_broadcaster.start (); } void nano::node::stop () @@ -699,6 +700,7 @@ void nano::node::stop () stats.stop (); epoch_upgrader.stop (); workers.stop (); + local_block_broadcaster.stop (); // work pool is not stopped on purpose due to testing setup } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index abd7b3651b..0776b72850 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -18,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -186,7 +186,7 @@ class node final : public std::enable_shared_from_this nano::bootstrap_ascending::service ascendboot; nano::websocket_server websocket; nano::epoch_upgrader epoch_upgrader; - nano::block_broadcast block_broadcast; + nano::local_block_broadcaster local_block_broadcaster; nano::process_live_dispatcher process_live_dispatcher; std::chrono::steady_clock::time_point const startup_time; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 4f1c158f98..75970d6ada 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -2228,7 +2228,7 @@ TEST (rpc, block_count_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - node1->process_active (send1); + node1->process_local (send1); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -2236,7 +2236,7 @@ TEST (rpc, block_count_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) .build (); - node1->process_active (receive1); + node1->process_local (receive1); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ())); // Pruning action From 42544be68ee053909ca0d1de70d9bfc224d34917 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Tue, 5 Mar 2024 18:34:20 +0000 Subject: [PATCH 135/190] Do not return node_id private key in RPC call (#4459) It could become a problem one day. This is breaking a debug API, that nobody should be using for serious tasks. So it should not cause any problems. --- nano/node/json_handler.cpp | 1 - nano/rpc_test/rpc.cpp | 1 - 2 files changed, 2 deletions(-) diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3ef09287ad..ec02593e0e 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -2922,7 +2922,6 @@ void nano::json_handler::node_id () { if (!ec) { - response_l.put ("private", node.node_id.prv.to_string ()); response_l.put ("public", node.node_id.pub.to_string ()); response_l.put ("as_account", node.node_id.pub.to_account ()); response_l.put ("node_id", node.node_id.pub.to_node_id ()); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 6dc67ff267..da0b1af1ae 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -5406,7 +5406,6 @@ TEST (rpc, node_id) boost::property_tree::ptree request; request.put ("action", "node_id"); auto response (wait_response (system, rpc_ctx, request)); - ASSERT_EQ (node->node_id.prv.to_string (), response.get ("private")); ASSERT_EQ (node->node_id.pub.to_account (), response.get ("as_account")); ASSERT_EQ (node->node_id.pub.to_node_id (), response.get ("node_id")); } From d2052cec80d76540776e2f519d25bfe0e0b79c52 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 27 Feb 2024 11:37:04 +0000 Subject: [PATCH 136/190] Make use of ledger::account overload taking a block when block is already available. --- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/json_handler.cpp | 2 +- nano/secure/ledger.cpp | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 1ab1362849..5f072a231a 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -132,7 +132,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, { case nano::block_status::progress: { - const auto account = ledger.account (tx, hash); + const auto account = ledger.account (block); const auto is_send = ledger.is_send (tx, block); // If we've inserted any block in to an account, unmark it as blocked diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3ef09287ad..3c2d4dd30b 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1214,7 +1214,7 @@ void nano::json_handler::block_confirm () nano::election_status status{ block_l, 0, 0, std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height }; node.active.recently_cemented.put (status); // Trigger callback for confirmed block - auto account (node.ledger.account (transaction, hash)); + auto account = node.ledger.account (*block_l); bool error_or_pruned (false); auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); bool is_state_send (false); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index d7464f4e07..979a4a3bab 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -63,7 +63,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto amount (ledger.amount (transaction, hash)); - auto destination_account (ledger.account (transaction, hash)); + auto destination_account = ledger.account (block_a); // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing [[maybe_unused]] bool is_pruned (false); auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned)); @@ -83,7 +83,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto amount (ledger.amount (transaction, hash)); - auto destination_account (ledger.account (transaction, hash)); + auto destination_account = ledger.account (block_a); // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing [[maybe_unused]] bool is_pruned (false); auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned)); @@ -99,7 +99,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto rep_block (ledger.representative (transaction, block_a.hashables.previous)); - auto account (ledger.account (transaction, block_a.hashables.previous)); + auto account = ledger.account (block_a); auto info = ledger.account_info (transaction, account); debug_assert (info); auto balance (ledger.balance (transaction, block_a.hashables.previous)); From f4dc825763f5f88f8e065546653374d6bd43de49 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 5 Mar 2024 19:07:43 +0000 Subject: [PATCH 137/190] Merge the ledger::account and ledger::account_safe functions in to a single function returning an optional value. This simplifies the ledger interface and uses safer std::optional to signal no value rather than a sentinel 0 value. --- nano/core_test/ledger.cpp | 7 +-- nano/node/bootstrap/bootstrap_server.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/json_handler.cpp | 32 ++++++------ nano/qt/qt.cpp | 28 ++++++++--- nano/secure/ledger.cpp | 59 +++++------------------ nano/secure/ledger.hpp | 15 ++---- 7 files changed, 57 insertions(+), 88 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index eb29e207d6..5ae86a07a0 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -5371,11 +5371,8 @@ TEST (ledger, pruning_safe_functions) ASSERT_EQ (0, ledger.amount_safe (transaction, send2->hash (), error)); ASSERT_TRUE (error); error = false; - ASSERT_TRUE (ledger.account_safe (transaction, send1->hash (), error).is_zero ()); - ASSERT_TRUE (error); - error = false; - ASSERT_EQ (nano::dev::genesis->account (), ledger.account_safe (transaction, send2->hash (), error)); - ASSERT_FALSE (error); + ASSERT_FALSE (ledger.account (transaction, send1->hash ())); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send2->hash ()).value ()); } TEST (ledger, hash_root_random) diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 5585212fd8..078d374d40 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -286,7 +286,7 @@ nano::asc_pull_ack nano::bootstrap_server::process (const store::transaction & t case asc_pull_req::hash_type::block: { // Try to lookup account assuming target is block hash - target = ledger.account_safe (transaction, request.target.as_block_hash ()); + target = ledger.account (transaction, request.target.as_block_hash ()).value_or (0); } break; } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 5f072a231a..0b6c85b7a0 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -166,7 +166,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, break; case nano::block_status::gap_source: { - const auto account = block.previous ().is_zero () ? block.account () : ledger.account (tx, block.previous ()); + const auto account = block.previous ().is_zero () ? block.account () : ledger.account (tx, block.previous ()).value (); const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); // Mark account as blocked because it is missing the source block diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3c2d4dd30b..c74d158303 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1388,7 +1388,7 @@ void nano::json_handler::blocks_info () auto block_a = node.ledger.block (transaction, source_hash); if (block_a != nullptr) { - auto source_account (node.ledger.account (transaction, source_hash)); + auto source_account (node.ledger.account (*block_a)); entry.put ("source_account", source_account.to_account ()); } else @@ -1432,10 +1432,10 @@ void nano::json_handler::block_account () if (!ec) { auto transaction (node.store.tx_begin_read ()); - if (node.ledger.block_exists (transaction, hash)) + auto block = node.ledger.block (transaction, hash); + if (block) { - auto account (node.ledger.account (transaction, hash)); - response_l.put ("account", account.to_account ()); + response_l.put ("account", node.ledger.account (*block).to_account ()); } else { @@ -2415,10 +2415,10 @@ class history_visitor : public nano::block_visitor auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); if (!error_or_pruned) { - auto source_account (handler.node.ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned)); - if (!error_or_pruned) + auto source_account = handler.node.ledger.account (transaction, block_a.hashables.source); + if (source_account) { - tree.put ("account", source_account.to_account ()); + tree.put ("account", source_account.value ().to_account ()); } tree.put ("amount", amount); } @@ -2448,10 +2448,10 @@ class history_visitor : public nano::block_visitor auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); if (!error_or_pruned) { - auto source_account (handler.node.ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned)); - if (!error_or_pruned) + auto source_account = handler.node.ledger.account (transaction, block_a.hashables.source); + if (source_account) { - tree.put ("account", source_account.to_account ()); + tree.put ("account", source_account.value ().to_account ()); } tree.put ("amount", amount); } @@ -2532,8 +2532,8 @@ class history_visitor : public nano::block_visitor } else { - auto source_account (handler.node.ledger.account_safe (transaction, block_a.hashables.link.as_block_hash (), error_or_pruned)); - if (!error_or_pruned && should_ignore_account (source_account)) + auto source_account = handler.node.ledger.account (transaction, block_a.hashables.link.as_block_hash ()); + if (source_account && should_ignore_account (source_account.value ())) { tree.clear (); return; @@ -2546,9 +2546,9 @@ class history_visitor : public nano::block_visitor { tree.put ("type", "receive"); } - if (!error_or_pruned) + if (source_account) { - tree.put ("account", source_account.to_account ()); + tree.put ("account", source_account.value ().to_account ()); } tree.put ("amount", (balance - previous_balance).convert_to ()); } @@ -2607,7 +2607,7 @@ void nano::json_handler::account_history () { if (node.ledger.block_exists (transaction, hash)) { - account = node.ledger.account (transaction, hash); + account = node.ledger.account (transaction, hash).value (); } else { @@ -5095,7 +5095,7 @@ void nano::json_handler::work_generate () auto transaction_l (node.store.tx_begin_read ()); if (node.ledger.block_exists (transaction_l, hash)) { - account = node.ledger.account (transaction_l, hash); + account = node.ledger.account (transaction_l, hash).value (); } } auto secondary_work_peers_l (request.get ("secondary_work_peers", false)); diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index efd112cd7b..253b3ed679 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -531,13 +531,17 @@ class short_text_visitor : public nano::block_visitor void receive_block (nano::receive_block const & block_a) { type = "Receive"; - bool error_or_pruned (false); - account = ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned); + auto account_l = ledger.account (transaction, block_a.hashables.source); + bool error_or_pruned = false; amount = ledger.amount_safe (transaction, block_a.hash (), error_or_pruned); - if (error_or_pruned) + if (!account_l || error_or_pruned) { type = "Receive (pruned)"; } + else + { + account = account_l.value (); + } } void open_block (nano::open_block const & block_a) { @@ -545,12 +549,16 @@ class short_text_visitor : public nano::block_visitor if (block_a.hashables.source != ledger.constants.genesis->account ()) { bool error_or_pruned (false); - account = ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned); + auto account_l = ledger.account (transaction, block_a.hashables.source); amount = ledger.amount_safe (transaction, block_a.hash (), error_or_pruned); - if (error_or_pruned) + if (!account_l || error_or_pruned) { type = "Receive (pruned)"; } + else + { + account = account_l.value (); + } } else { @@ -596,11 +604,15 @@ class short_text_visitor : public nano::block_visitor else { type = "Receive"; - account = ledger.account_safe (transaction, block_a.hashables.link.as_block_hash (), error_or_pruned); - if (error_or_pruned) + auto account_l = ledger.account (transaction, block_a.hashables.link.as_block_hash ()); + if (!account_l) { type = "Receive (pruned)"; } + else + { + account = account_l.value (); + } } amount = balance - previous_balance; } @@ -609,7 +621,7 @@ class short_text_visitor : public nano::block_visitor nano::ledger & ledger; std::string type; nano::uint128_t amount; - nano::account account; + nano::account account{ 0 }; }; } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 979a4a3bab..7d0bd4d573 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -65,15 +65,14 @@ class rollback_visitor : public nano::block_visitor auto amount (ledger.amount (transaction, hash)); auto destination_account = ledger.account (block_a); // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing - [[maybe_unused]] bool is_pruned (false); - auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned)); + auto source_account = ledger.account (transaction, block_a.hashables.source); auto info = ledger.account_info (transaction, destination_account); debug_assert (info); 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.update_account (transaction, destination_account, *info, new_info); ledger.store.block.del (transaction, hash); - ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); + ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account.value_or (0), amount, nano::epoch::epoch_0 }); ledger.store.frontier.del (transaction, hash); ledger.store.frontier.put (transaction, block_a.hashables.previous, destination_account); ledger.store.block.successor_clear (transaction, block_a.hashables.previous); @@ -84,14 +83,12 @@ class rollback_visitor : public nano::block_visitor auto hash (block_a.hash ()); auto amount (ledger.amount (transaction, hash)); auto destination_account = ledger.account (block_a); - // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing - [[maybe_unused]] bool is_pruned (false); - auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned)); + auto source_account = ledger.account (transaction, block_a.hashables.source); ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); nano::account_info new_info; ledger.update_account (transaction, destination_account, new_info, new_info); ledger.store.block.del (transaction, hash); - ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); + ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account.value_or (0), amount, nano::epoch::epoch_0 }); ledger.store.frontier.del (transaction, hash); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open); } @@ -156,9 +153,8 @@ class rollback_visitor : public nano::block_visitor else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link)) { // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing - [[maybe_unused]] bool is_pruned (false); - auto source_account (ledger.account_safe (transaction, block_a.hashables.link.as_block_hash (), is_pruned)); - nano::pending_info pending_info (source_account, block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch); + auto source_account = ledger.account (transaction, block_a.hashables.link.as_block_hash ()); + nano::pending_info pending_info (source_account.value_or (0), block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch); ledger.store.pending.put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } @@ -1109,7 +1105,7 @@ nano::uint128_t nano::ledger::weight (nano::account const & account_a) bool nano::ledger::rollback (store::write_transaction const & transaction_a, nano::block_hash const & block_a, std::vector> & list_a) { debug_assert (block_exists (transaction_a, block_a)); - auto account_l (account (transaction_a, block_a)); + auto account_l = account (transaction_a, block_a).value (); auto block_account_height (height (transaction_a, block_a)); rollback_visitor rollback (transaction_a, *this, list_a); auto error (false); @@ -1144,7 +1140,7 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan return rollback (transaction_a, block_a, rollback_list); } -nano::account nano::ledger::account (nano::block const & block) const +nano::account nano::ledger::account (nano::block const & block) { debug_assert (block.has_sideband ()); nano::account result (block.account ()); @@ -1156,45 +1152,14 @@ nano::account nano::ledger::account (nano::block const & block) const return result; } -nano::account nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const +std::optional nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const { auto block_l = block (transaction, hash); - debug_assert (block_l != nullptr); - return account (*block_l); -} - -nano::account nano::ledger::account_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const -{ - if (!pruning) + if (!block_l) { - return account (transaction_a, hash_a); - } - else - { - auto block_l = block (transaction_a, hash_a); - if (block_l != nullptr) - { - return account (*block_l); - } - else - { - error_a = true; - return 0; - } - } -} - -nano::account nano::ledger::account_safe (store::transaction const & transaction, nano::block_hash const & hash) const -{ - auto block_l = block (transaction, hash); - if (block_l) - { - return account (*block_l); - } - else - { - return { 0 }; + return std::nullopt; } + return account (*block_l); } std::optional nano::ledger::account_info (store::transaction const & transaction, nano::account const & account) const diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 52accb506c..b606d1b729 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -33,18 +33,13 @@ class ledger final /** * Return account containing hash, expects that block hash exists in ledger */ - nano::account account (nano::block const & block) const; - nano::account account (store::transaction const &, nano::block_hash const &) const; - std::optional account_info (store::transaction const & transaction, nano::account const & account) const; - /** - * For non-prunning nodes same as `ledger::account()` - * For prunning nodes ensures that block hash exists, otherwise returns zero account - */ - nano::account account_safe (store::transaction const &, nano::block_hash const &, bool &) const; + static nano::account account (nano::block const & block); /** - * Return account containing hash, returns zero account if account can not be found + * Returns the account for a given hash + * Returns std::nullopt if the block doesn't exist or has been pruned */ - nano::account account_safe (store::transaction const &, nano::block_hash const &) const; + std::optional account (store::transaction const &, nano::block_hash const &) const; + std::optional account_info (store::transaction const & transaction, nano::account const & account) const; nano::uint128_t amount (store::transaction const &, nano::block_hash const &); /** Safe for previous block, but block hash_a must exist */ nano::uint128_t amount_safe (store::transaction const &, nano::block_hash const & hash_a, bool &) const; From 3ce52fc49af80dbb73187fe903da1e7b3c0a719d Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 11:58:46 +0000 Subject: [PATCH 138/190] ledger::amount will no longer query for the previous block's balance if the previous hash is zero. This removes a dependency on the behaviour of ledger::balance to return a sentinel value of 0 if the block hash cannot be found. --- nano/secure/ledger.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 7d0bd4d573..2d367990f8 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1171,6 +1171,10 @@ nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, { auto block_l = block (transaction_a, hash_a); auto block_balance (balance (transaction_a, hash_a)); + if (block_l->previous ().is_zero ()) + { + return block_balance; + } auto previous_balance (balance (transaction_a, block_l->previous ())); return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; } @@ -1180,6 +1184,10 @@ nano::uint128_t nano::ledger::amount_safe (store::transaction const & transactio auto block_l = block (transaction_a, hash_a); debug_assert (block_l); auto block_balance (balance (transaction_a, hash_a)); + if (block_l->previous ().is_zero ()) + { + return block_balance; + } auto previous_balance (balance_safe (transaction_a, block_l->previous (), error_a)); return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; From 4bac9419795f8a2789c240e25fae8fad55c3b671 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 27 Feb 2024 15:43:55 +0000 Subject: [PATCH 139/190] Merging ledger::balance_safe with ledger::balance and returning value as an std::optional. --- nano/core_test/ledger.cpp | 8 +--- nano/nano_node/entry.cpp | 11 +++--- nano/node/bootstrap/bootstrap_lazy.cpp | 14 +++---- nano/node/json_handler.cpp | 17 ++++----- nano/node/node.cpp | 7 ++-- nano/node/scheduler/priority.cpp | 4 +- nano/qt/qt.cpp | 9 ++--- nano/secure/ledger.cpp | 53 ++++++++++---------------- nano/secure/ledger.hpp | 3 +- 9 files changed, 52 insertions(+), 74 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 5ae86a07a0..0cce4c94c3 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -5361,13 +5361,9 @@ TEST (ledger, pruning_safe_functions) ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Safe ledger actions + ASSERT_FALSE (ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance (transaction, send2->hash ()).value ()); bool error (false); - ASSERT_EQ (0, ledger.balance_safe (transaction, send1->hash (), error)); - ASSERT_TRUE (error); - error = false; - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance_safe (transaction, send2->hash (), error)); - ASSERT_FALSE (error); - error = false; ASSERT_EQ (0, ledger.amount_safe (transaction, send2->hash (), error)); ASSERT_TRUE (error); error = false; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 744df8d63b..25b17af5e2 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1494,7 +1494,7 @@ int main (int argc, char * const * argv) bool error_or_pruned (false); if (!state_block.hashables.previous.is_zero ()) { - prev_balance = node->ledger.balance_safe (transaction, state_block.hashables.previous, error_or_pruned); + prev_balance = node->ledger.balance (transaction, state_block.hashables.previous).value_or (0); } if (node->ledger.is_epoch_link (state_block.hashables.link)) { @@ -1518,11 +1518,10 @@ int main (int argc, char * const * argv) } else { - bool error_or_pruned (false); - auto prev_balance (node->ledger.balance_safe (transaction, block->previous (), error_or_pruned)); - if (!node->ledger.pruning || !error_or_pruned) + auto prev_balance = node->ledger.balance (transaction, block->previous ()); + if (!node->ledger.pruning || prev_balance) { - if (block->balance () < prev_balance) + if (block->balance () < prev_balance.value ()) { // State send block_details_error = !sideband.details.is_send || sideband.details.is_receive || sideband.details.is_epoch; @@ -1534,7 +1533,7 @@ int main (int argc, char * const * argv) // State change block_details_error = sideband.details.is_send || sideband.details.is_receive || sideband.details.is_epoch; } - else if (block->balance () == prev_balance && node->ledger.is_epoch_link (block->link ())) + else if (block->balance () == prev_balance.value () && node->ledger.is_epoch_link (block->link ())) { // State epoch block_details_error = !sideband.details.is_epoch || sideband.details.is_send || sideband.details.is_receive; diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index d69916a9c9..49cd39c03e 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -346,11 +346,10 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptrledger.block_or_pruned_exists (transaction, previous)) { - bool error_or_pruned (false); - auto previous_balance (node->ledger.balance_safe (transaction, previous, error_or_pruned)); - if (!error_or_pruned) + auto previous_balance = node->ledger.balance (transaction, previous); + if (previous_balance) { - if (previous_balance <= balance) + if (previous_balance.value () <= balance) { lazy_add (link, retry_limit); } @@ -423,11 +422,10 @@ void nano::bootstrap_attempt_lazy::lazy_backlog_cleanup () if (node->ledger.block_or_pruned_exists (transaction, it->first)) { auto next_block (it->second); - bool error_or_pruned (false); - auto balance (node->ledger.balance_safe (transaction, it->first, error_or_pruned)); - if (!error_or_pruned) + auto balance = node->ledger.balance (transaction, it->first); + if (balance) { - if (balance <= next_block.balance) // balance + if (balance.value () <= next_block.balance) // balance { lazy_add (next_block.link, next_block.retry_limit); // link } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index c74d158303..f113b5923d 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -641,7 +641,7 @@ void nano::json_handler::account_info () { if (info.block_count != confirmation_height_info.height) { - confirmed_balance_l = node.ledger.balance (transaction, confirmation_height_info.frontier); + confirmed_balance_l = node.ledger.balance (transaction, confirmation_height_info.frontier).value_or (0); } else { @@ -1156,7 +1156,7 @@ void nano::json_handler::block_info () { response_l.put ("amount", amount.convert_to ()); } - auto balance (node.ledger.balance (transaction, hash)); + auto balance = node.ledger.balance (*block); response_l.put ("balance", balance.convert_to ()); response_l.put ("height", std::to_string (block->sideband ().height)); response_l.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); @@ -1315,7 +1315,7 @@ void nano::json_handler::blocks_info () { entry.put ("amount", amount.convert_to ()); } - auto balance (node.ledger.balance (transaction, hash)); + auto balance = node.ledger.balance (*block); entry.put ("balance", balance.convert_to ()); entry.put ("height", std::to_string (block->sideband ().height)); entry.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); @@ -2482,9 +2482,8 @@ class history_visitor : public nano::block_visitor tree.put ("previous", block_a.hashables.previous.to_string ()); } auto balance (block_a.hashables.balance.number ()); - bool error_or_pruned (false); - auto previous_balance (handler.node.ledger.balance_safe (transaction, block_a.hashables.previous, error_or_pruned)); - if (error_or_pruned) + auto previous_balance = handler.node.ledger.balance (transaction, block_a.hashables.previous); + if (!previous_balance) { if (raw) { @@ -2495,7 +2494,7 @@ class history_visitor : public nano::block_visitor tree.put ("type", "unknown"); } } - else if (balance < previous_balance) + else if (balance < previous_balance.value ()) { if (should_ignore_account (block_a.hashables.link.as_account ())) { @@ -2511,7 +2510,7 @@ class history_visitor : public nano::block_visitor tree.put ("type", "send"); } tree.put ("account", block_a.hashables.link.to_account ()); - tree.put ("amount", (previous_balance - balance).convert_to ()); + tree.put ("amount", (previous_balance.value () - balance).convert_to ()); } else { @@ -2550,7 +2549,7 @@ class history_visitor : public nano::block_visitor { tree.put ("account", source_account.value ().to_account ()); } - tree.put ("amount", (balance - previous_balance).convert_to ()); + tree.put ("amount", (balance - previous_balance.value ()).convert_to ()); } } } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index b202b8b018..4ed49e6e3f 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1232,14 +1232,13 @@ void nano::node::process_confirmed_data (store::transaction const & transaction_ } // Faster amount calculation auto previous (block_a->previous ()); - bool error (false); - auto previous_balance (ledger.balance_safe (transaction_a, previous, error)); + auto previous_balance = ledger.balance (transaction_a, previous); auto block_balance = ledger.balance (*block_a); if (hash_a != ledger.constants.genesis->account ()) { - if (!error) + if (previous_balance) { - amount_a = block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; + amount_a = block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; } else { diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index c503601a93..649502c189 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -51,8 +51,8 @@ bool nano::scheduler::priority::activate (nano::account const & account_a, store debug_assert (block != nullptr); if (node.ledger.dependents_confirmed (transaction, *block)) { - auto const balance = node.ledger.balance (transaction, hash); - auto const previous_balance = node.ledger.balance (transaction, conf_info.frontier); + auto const balance = node.ledger.balance (transaction, hash).value (); + auto const previous_balance = node.ledger.balance (transaction, conf_info.frontier).value_or (0); auto const balance_priority = std::max (balance, previous_balance); node.stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::activated); diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 253b3ed679..2f0c27ba31 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -575,9 +575,8 @@ class short_text_visitor : public nano::block_visitor void state_block (nano::state_block const & block_a) { auto balance (block_a.hashables.balance.number ()); - bool error_or_pruned (false); - auto previous_balance (ledger.balance_safe (transaction, block_a.hashables.previous, error_or_pruned)); - if (error_or_pruned) + auto previous_balance = ledger.balance (transaction, block_a.hashables.previous); + if (!previous_balance) { type = "Unknown (pruned)"; amount = 0; @@ -586,7 +585,7 @@ class short_text_visitor : public nano::block_visitor else if (balance < previous_balance) { type = "Send"; - amount = previous_balance - balance; + amount = previous_balance.value () - balance; account = block_a.hashables.link.as_account (); } else @@ -614,7 +613,7 @@ class short_text_visitor : public nano::block_visitor account = account_l.value (); } } - amount = balance - previous_balance; + amount = balance - previous_balance.value (); } } nano::store::transaction const & transaction; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 2d367990f8..c4da525c96 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -50,7 +50,7 @@ class rollback_visitor : public nano::block_visitor debug_assert (info); 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); + nano::account_info new_info (block_a.hashables.previous, info->representative, info->open_block, ledger.balance (transaction, block_a.hashables.previous).value (), nano::seconds_since_epoch (), info->block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, pending.source, *info, new_info); ledger.store.block.del (transaction, hash); ledger.store.frontier.del (transaction, hash); @@ -69,7 +69,7 @@ class rollback_visitor : public nano::block_visitor auto info = ledger.account_info (transaction, destination_account); debug_assert (info); 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); + nano::account_info new_info (block_a.hashables.previous, info->representative, info->open_block, ledger.balance (transaction, block_a.hashables.previous).value (), nano::seconds_since_epoch (), info->block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, destination_account, *info, new_info); ledger.store.block.del (transaction, hash); ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account.value_or (0), amount, nano::epoch::epoch_0 }); @@ -99,7 +99,7 @@ class rollback_visitor : public nano::block_visitor auto account = ledger.account (block_a); auto info = ledger.account_info (transaction, account); debug_assert (info); - auto balance (ledger.balance (transaction, block_a.hashables.previous)); + auto balance = ledger.balance (transaction, block_a.hashables.previous).value (); auto block = ledger.store.block.get (transaction, rep_block); release_assert (block != nullptr); auto representative = block->representative (); @@ -120,7 +120,7 @@ class rollback_visitor : public nano::block_visitor { rep_block_hash = ledger.representative (transaction, block_a.hashables.previous); } - auto balance (ledger.balance (transaction, block_a.hashables.previous)); + nano::uint128_t balance = ledger.balance (transaction, block_a.hashables.previous).value_or (0); auto is_send (block_a.hashables.balance < balance); nano::account representative{}; if (!rep_block_hash.is_zero ()) @@ -215,7 +215,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::progress : nano::block_status::gap_previous; if (result == nano::block_status::progress) { - prev_balance = ledger.balance (transaction, block_a.hashables.previous); + prev_balance = ledger.balance (transaction, block_a.hashables.previous).value (); } else { @@ -479,7 +479,7 @@ void ledger_processor::change_block (nano::change_block & block_a) debug_assert (!validate_message (account, hash, block_a.signature)); block_a.sideband_set (nano::block_sideband (account, 0, info->balance, info->block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); - auto balance (ledger.balance (transaction, block_a.hashables.previous)); + auto balance = ledger.balance (*previous); ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance, info->representative, 0 - balance); nano::account_info new_info (hash, block_a.representative (), info->open_block, info->balance, nano::seconds_since_epoch (), info->block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, *info, new_info); @@ -830,30 +830,18 @@ nano::uint128_t nano::ledger::balance (nano::block const & block) } // Balance for account containing hash -nano::uint128_t nano::ledger::balance (store::transaction const & transaction, nano::block_hash const & hash) const +std::optional nano::ledger::balance (store::transaction const & transaction, nano::block_hash const & hash) const { if (hash.is_zero ()) { - return 0; - } - auto block_l = block (transaction, hash); - debug_assert (block_l != nullptr); - return balance (*block_l); -} - -nano::uint128_t nano::ledger::balance_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const -{ - nano::uint128_t result (0); - if (pruning && !hash_a.is_zero () && !block_exists (transaction_a, hash_a)) - { - error_a = true; - result = 0; + return std::nullopt; } - else + auto block = store.block.get (transaction, hash); + if (!block) { - result = balance (transaction_a, hash_a); + return std::nullopt; } - return result; + return balance (*block); } std::shared_ptr nano::ledger::block (store::transaction const & transaction, nano::block_hash const & hash) const @@ -875,7 +863,7 @@ nano::uint128_t nano::ledger::account_balance (store::transaction const & transa nano::confirmation_height_info info; if (!store.confirmation_height.get (transaction_a, account_a, info)) { - result = balance (transaction_a, info.frontier); + result = balance (transaction_a, info.frontier).value (); } } else @@ -1170,27 +1158,28 @@ std::optional nano::ledger::account_info (store::transaction nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a) { auto block_l = block (transaction_a, hash_a); - auto block_balance (balance (transaction_a, hash_a)); + auto block_balance = balance (*block_l); if (block_l->previous ().is_zero ()) { return block_balance; } - auto previous_balance (balance (transaction_a, block_l->previous ())); - return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; + auto previous_balance = balance (transaction_a, block_l->previous ()); + return block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; } nano::uint128_t nano::ledger::amount_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { auto block_l = block (transaction_a, hash_a); debug_assert (block_l); - auto block_balance (balance (transaction_a, hash_a)); + auto block_balance = balance (*block_l); if (block_l->previous ().is_zero ()) { return block_balance; } - auto previous_balance (balance_safe (transaction_a, block_l->previous (), error_a)); - return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance - : previous_balance - block_balance; + auto previous_balance = balance (transaction_a, block_l->previous ()); + error_a = !previous_balance; + return error_a ? 0 : block_balance > previous_balance.value () ? block_balance - previous_balance.value () + : previous_balance.value () - block_balance; } // Return latest block for account diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index b606d1b729..0d025bcc2d 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -44,8 +44,7 @@ class ledger final /** Safe for previous block, but block hash_a must exist */ nano::uint128_t amount_safe (store::transaction const &, nano::block_hash const & hash_a, bool &) const; static nano::uint128_t balance (nano::block const & block); - nano::uint128_t balance (store::transaction const &, nano::block_hash const &) const; - nano::uint128_t balance_safe (store::transaction const &, nano::block_hash const &, bool &) const; + std::optional balance (store::transaction const &, nano::block_hash const &) const; std::shared_ptr block (store::transaction const & transaction, nano::block_hash const & hash) const; bool block_exists (store::transaction const & transaction, nano::block_hash const & hash) const; nano::uint128_t account_balance (store::transaction const &, nano::account const &, bool = false); From 2810e4cc5ff511590685c1bd80c97017ff5622aa Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 27 Feb 2024 16:12:06 +0000 Subject: [PATCH 140/190] Merge ledger::amount_safe in to ledger::amount and change return value to std::optional --- nano/core_test/ledger.cpp | 5 +---- nano/node/json_handler.cpp | 43 +++++++++++++++++--------------------- nano/qt/qt.cpp | 21 +++++++++++-------- nano/secure/ledger.cpp | 27 +++++++++--------------- nano/secure/ledger.hpp | 4 +--- 5 files changed, 43 insertions(+), 57 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 0cce4c94c3..b8c827a9f9 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -5363,10 +5363,7 @@ TEST (ledger, pruning_safe_functions) // Safe ledger actions ASSERT_FALSE (ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance (transaction, send2->hash ()).value ()); - bool error (false); - ASSERT_EQ (0, ledger.amount_safe (transaction, send2->hash (), error)); - ASSERT_TRUE (error); - error = false; + ASSERT_FALSE (ledger.amount (transaction, send2->hash ())); ASSERT_FALSE (ledger.account (transaction, send1->hash ())); ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send2->hash ()).value ()); } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index f113b5923d..cba140a7f2 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1150,11 +1150,10 @@ void nano::json_handler::block_info () { nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); response_l.put ("block_account", account.to_account ()); - bool error_or_pruned (false); - auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); - if (!error_or_pruned) + auto amount = node.ledger.amount (transaction, hash); + if (amount) { - response_l.put ("amount", amount.convert_to ()); + response_l.put ("amount", amount.value ().convert_to ()); } auto balance = node.ledger.balance (*block); response_l.put ("balance", balance.convert_to ()); @@ -1215,19 +1214,18 @@ void nano::json_handler::block_confirm () node.active.recently_cemented.put (status); // Trigger callback for confirmed block auto account = node.ledger.account (*block_l); - bool error_or_pruned (false); - auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); + auto amount = node.ledger.amount (transaction, hash); bool is_state_send (false); bool is_state_epoch (false); - if (!error_or_pruned) + if (amount) { if (auto state = dynamic_cast (block_l.get ())) { is_state_send = node.ledger.is_send (transaction, *state); - is_state_epoch = amount == 0 && node.ledger.is_epoch_link (state->link ()); + is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link ()); } } - node.observers.blocks.notify (status, {}, account, amount, is_state_send, is_state_epoch); + node.observers.blocks.notify (status, {}, account, amount ? amount.value () : 0, is_state_send, is_state_epoch); } response_l.put ("started", "1"); } @@ -1309,11 +1307,10 @@ void nano::json_handler::blocks_info () boost::property_tree::ptree entry; nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); entry.put ("block_account", account.to_account ()); - bool error_or_pruned (false); - auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); - if (!error_or_pruned) + auto amount = node.ledger.amount (transaction, hash); + if (amount) { - entry.put ("amount", amount.convert_to ()); + entry.put ("amount", amount.value ().convert_to ()); } auto balance = node.ledger.balance (*block); entry.put ("balance", balance.convert_to ()); @@ -2395,11 +2392,10 @@ class history_visitor : public nano::block_visitor tree.put ("type", "send"); auto account (block_a.hashables.destination.to_account ()); tree.put ("account", account); - bool error_or_pruned (false); - auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); - if (!error_or_pruned) + auto amount = handler.node.ledger.amount (transaction, hash); + if (amount) { - tree.put ("amount", amount); + tree.put ("amount", amount.value ().convert_to ()); } if (raw) { @@ -2411,16 +2407,15 @@ class history_visitor : public nano::block_visitor void receive_block (nano::receive_block const & block_a) { tree.put ("type", "receive"); - bool error_or_pruned (false); - auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); - if (!error_or_pruned) + auto amount = handler.node.ledger.amount (transaction, hash); + if (amount) { auto source_account = handler.node.ledger.account (transaction, block_a.hashables.source); if (source_account) { tree.put ("account", source_account.value ().to_account ()); } - tree.put ("amount", amount); + tree.put ("amount", amount.value ().convert_to ()); } if (raw) { @@ -2445,15 +2440,15 @@ class history_visitor : public nano::block_visitor if (block_a.hashables.source != handler.node.ledger.constants.genesis->account ()) { bool error_or_pruned (false); - auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); - if (!error_or_pruned) + auto amount = handler.node.ledger.amount (transaction, hash); + if (amount) { auto source_account = handler.node.ledger.account (transaction, block_a.hashables.source); if (source_account) { tree.put ("account", source_account.value ().to_account ()); } - tree.put ("amount", amount); + tree.put ("amount", amount.value ().convert_to ()); } } else diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 2f0c27ba31..73f719bfdc 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -521,26 +521,29 @@ class short_text_visitor : public nano::block_visitor { type = "Send"; account = block_a.hashables.destination; - bool error_or_pruned (false); - amount = ledger.amount_safe (transaction, block_a.hash (), error_or_pruned); - if (error_or_pruned) + auto amount_l = ledger.amount (transaction, block_a.hash ()); + if (!amount_l) { type = "Send (pruned)"; } + else + { + amount = amount_l.value (); + } } void receive_block (nano::receive_block const & block_a) { type = "Receive"; auto account_l = ledger.account (transaction, block_a.hashables.source); - bool error_or_pruned = false; - amount = ledger.amount_safe (transaction, block_a.hash (), error_or_pruned); - if (!account_l || error_or_pruned) + auto amount_l = ledger.amount (transaction, block_a.hash ()); + if (!account_l || !amount_l) { type = "Receive (pruned)"; } else { account = account_l.value (); + amount = amount_l.value (); } } void open_block (nano::open_block const & block_a) @@ -548,16 +551,16 @@ class short_text_visitor : public nano::block_visitor type = "Receive"; if (block_a.hashables.source != ledger.constants.genesis->account ()) { - bool error_or_pruned (false); auto account_l = ledger.account (transaction, block_a.hashables.source); - amount = ledger.amount_safe (transaction, block_a.hash (), error_or_pruned); - if (!account_l || error_or_pruned) + auto amount_l = ledger.amount (transaction, block_a.hash ()); + if (!account_l || !amount_l) { type = "Receive (pruned)"; } else { account = account_l.value (); + amount = amount_l.value (); } } else diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index c4da525c96..c27abacb63 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -62,7 +62,7 @@ class rollback_visitor : public nano::block_visitor void receive_block (nano::receive_block const & block_a) override { auto hash (block_a.hash ()); - auto amount (ledger.amount (transaction, hash)); + auto amount = ledger.amount (transaction, hash).value (); auto destination_account = ledger.account (block_a); // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing auto source_account = ledger.account (transaction, block_a.hashables.source); @@ -81,7 +81,7 @@ class rollback_visitor : public nano::block_visitor void open_block (nano::open_block const & block_a) override { auto hash (block_a.hash ()); - auto amount (ledger.amount (transaction, hash)); + auto amount = ledger.amount (transaction, hash).value (); auto destination_account = ledger.account (block_a); auto source_account = ledger.account (transaction, block_a.hashables.source); ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); @@ -1155,31 +1155,24 @@ std::optional nano::ledger::account_info (store::transaction return store.account.get (transaction, account); } -nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a) +std::optional nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a) { auto block_l = block (transaction_a, hash_a); - auto block_balance = balance (*block_l); - if (block_l->previous ().is_zero ()) + if (!block_l) { - return block_balance; + return std::nullopt; } - auto previous_balance = balance (transaction_a, block_l->previous ()); - return block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; -} - -nano::uint128_t nano::ledger::amount_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const -{ - auto block_l = block (transaction_a, hash_a); - debug_assert (block_l); auto block_balance = balance (*block_l); if (block_l->previous ().is_zero ()) { return block_balance; } auto previous_balance = balance (transaction_a, block_l->previous ()); - error_a = !previous_balance; - return error_a ? 0 : block_balance > previous_balance.value () ? block_balance - previous_balance.value () - : previous_balance.value () - block_balance; + if (!previous_balance) + { + return std::nullopt; + } + return block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; } // Return latest block for account diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 0d025bcc2d..6b3eddd698 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -40,9 +40,7 @@ class ledger final */ std::optional account (store::transaction const &, nano::block_hash const &) const; std::optional account_info (store::transaction const & transaction, nano::account const & account) const; - nano::uint128_t amount (store::transaction const &, nano::block_hash const &); - /** Safe for previous block, but block hash_a must exist */ - nano::uint128_t amount_safe (store::transaction const &, nano::block_hash const & hash_a, bool &) const; + std::optional amount (store::transaction const &, nano::block_hash const &); static nano::uint128_t balance (nano::block const & block); std::optional balance (store::transaction const &, nano::block_hash const &) const; std::shared_ptr block (store::transaction const & transaction, nano::block_hash const & hash) const; From ece1cfd6db9fa630bc591ca2b43f1b31764ab610 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 6 Mar 2024 17:40:18 +0000 Subject: [PATCH 141/190] Update minimum OSX deployment target to 13.3 which is required by the OSX 14.4 SDK. (#4464) Fixes error: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.4.sdk/usr/include/c++/v1/__format/formatter_floating_point.h:66:32: error: 'to_chars' is unavailable: introduced in macOS 13.3 --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0123485cdf..c411cee10e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,7 @@ endif() # OSX compatibility needs to be set before project is declared set(CMAKE_OSX_DEPLOYMENT_TARGET - 12 + 13.3 CACHE STRING "") project(nano-node) From d4cbf1eaf3b1f95629761976debdf0d65006f78d Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 00:32:00 +0000 Subject: [PATCH 142/190] Move nano::block_sideband and nano::block_type in to their own files. --- nano/lib/CMakeLists.txt | 4 +++ nano/lib/block_sideband.cpp | 0 nano/lib/block_sideband.hpp | 68 ++++++++++++++++++++++++++++++++++++ nano/lib/block_type.cpp | 13 +++++++ nano/lib/block_type.hpp | 26 ++++++++++++++ nano/lib/blocks.cpp | 10 ------ nano/lib/blocks.hpp | 69 +------------------------------------ nano/store/block.hpp | 1 + 8 files changed, 113 insertions(+), 78 deletions(-) create mode 100644 nano/lib/block_sideband.cpp create mode 100644 nano/lib/block_sideband.hpp create mode 100644 nano/lib/block_type.cpp create mode 100644 nano/lib/block_type.hpp diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 271091dcef..9612fdf804 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -21,6 +21,10 @@ add_library( ${platform_sources} asio.hpp asio.cpp + block_sideband.hpp + block_sideband.cpp + block_type.hpp + block_type.cpp blockbuilders.hpp blockbuilders.cpp blocks.hpp diff --git a/nano/lib/block_sideband.cpp b/nano/lib/block_sideband.cpp new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nano/lib/block_sideband.hpp b/nano/lib/block_sideband.hpp new file mode 100644 index 0000000000..dc7e8a428e --- /dev/null +++ b/nano/lib/block_sideband.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include + +namespace nano +{ +class object_stream; +} + +namespace nano +{ +class block_details +{ + static_assert (std::is_same::type, uint8_t> (), "Epoch enum is not the proper type"); + static_assert (static_cast (nano::epoch::max) < (1 << 5), "Epoch max is too large for the sideband"); + +public: + block_details () = default; + block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a); + static constexpr size_t size () + { + return 1; + } + bool operator== (block_details const & other_a) const; + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + nano::epoch epoch{ nano::epoch::epoch_0 }; + bool is_send{ false }; + bool is_receive{ false }; + bool is_epoch{ false }; + +private: + uint8_t packed () const; + void unpack (uint8_t); + +public: // Logging + void operator() (nano::object_stream &) const; +}; + +std::string state_subtype (nano::block_details const); + +class block_sideband final +{ +public: + block_sideband () = default; + block_sideband (nano::account const &, nano::block_hash const &, nano::amount const &, uint64_t const, nano::seconds_t const local_timestamp, nano::block_details const &, nano::epoch const source_epoch_a); + block_sideband (nano::account const &, nano::block_hash const &, nano::amount const &, uint64_t const, nano::seconds_t const local_timestamp, nano::epoch const epoch_a, bool const is_send, bool const is_receive, bool const is_epoch, nano::epoch const source_epoch_a); + void serialize (nano::stream &, nano::block_type) const; + bool deserialize (nano::stream &, nano::block_type); + static size_t size (nano::block_type); + nano::block_hash successor{ 0 }; + nano::account account{}; + nano::amount balance{ 0 }; + uint64_t height{ 0 }; + uint64_t timestamp{ 0 }; + nano::block_details details; + nano::epoch source_epoch{ nano::epoch::epoch_0 }; + +public: // Logging + void operator() (nano::object_stream &) const; +}; +} // namespace nano diff --git a/nano/lib/block_type.cpp b/nano/lib/block_type.cpp new file mode 100644 index 0000000000..4afb9b0fdb --- /dev/null +++ b/nano/lib/block_type.cpp @@ -0,0 +1,13 @@ +#include + +#include + +std::string_view nano::to_string (nano::block_type type) +{ + return magic_enum::enum_name (type); +} + +void nano::serialize_block_type (nano::stream & stream, const nano::block_type & type) +{ + nano::write (stream, type); +} diff --git a/nano/lib/block_type.hpp b/nano/lib/block_type.hpp new file mode 100644 index 0000000000..020722e315 --- /dev/null +++ b/nano/lib/block_type.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include + +#include +#include + +namespace nano +{ +enum class block_type : uint8_t +{ + invalid = 0, + not_a_block = 1, + send = 2, + receive = 3, + open = 4, + change = 5, + state = 6 +}; + +std::string_view to_string (block_type); +/** + * Serialize block type as an 8-bit value + */ +void serialize_block_type (nano::stream &, nano::block_type const &); +} // namespace nano diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 3a13bb3868..0ad893339d 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -1443,11 +1443,6 @@ std::shared_ptr nano::deserialize_block_json (boost::property_tree: return result; } -void nano::serialize_block_type (nano::stream & stream, const nano::block_type & type) -{ - nano::write (stream, type); -} - void nano::serialize_block (nano::stream & stream_a, nano::block const & block_a) { nano::serialize_block_type (stream_a, block_a.type ()); @@ -1986,8 +1981,3 @@ void nano::block_sideband::operator() (nano::object_stream & obs) const obs.write ("source_epoch", source_epoch); obs.write ("details", details); } - -std::string_view nano::to_string (nano::block_type type) -{ - return magic_enum::enum_name (type); -} diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 19c31d95eb..0fb5aee4ae 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include @@ -21,70 +22,6 @@ namespace nano class block_visitor; class mutable_block_visitor; -enum class block_type : uint8_t -{ - invalid = 0, - not_a_block = 1, - send = 2, - receive = 3, - open = 4, - change = 5, - state = 6 -}; - -std::string_view to_string (block_type); - -class block_details -{ - static_assert (std::is_same::type, uint8_t> (), "Epoch enum is not the proper type"); - static_assert (static_cast (nano::epoch::max) < (1 << 5), "Epoch max is too large for the sideband"); - -public: - block_details () = default; - block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a); - static constexpr size_t size () - { - return 1; - } - bool operator== (block_details const & other_a) const; - void serialize (nano::stream &) const; - bool deserialize (nano::stream &); - nano::epoch epoch{ nano::epoch::epoch_0 }; - bool is_send{ false }; - bool is_receive{ false }; - bool is_epoch{ false }; - -private: - uint8_t packed () const; - void unpack (uint8_t); - -public: // Logging - void operator() (nano::object_stream &) const; -}; - -std::string state_subtype (nano::block_details const); - -class block_sideband final -{ -public: - block_sideband () = default; - block_sideband (nano::account const &, nano::block_hash const &, nano::amount const &, uint64_t const, nano::seconds_t const local_timestamp, nano::block_details const &, nano::epoch const source_epoch_a); - block_sideband (nano::account const &, nano::block_hash const &, nano::amount const &, uint64_t const, nano::seconds_t const local_timestamp, nano::epoch const epoch_a, bool const is_send, bool const is_receive, bool const is_epoch, nano::epoch const source_epoch_a); - void serialize (nano::stream &, nano::block_type) const; - bool deserialize (nano::stream &, nano::block_type); - static size_t size (nano::block_type); - nano::block_hash successor{ 0 }; - nano::account account{}; - nano::amount balance{ 0 }; - uint64_t height{ 0 }; - uint64_t timestamp{ 0 }; - nano::block_details details; - nano::epoch source_epoch{ nano::epoch::epoch_0 }; - -public: // Logging - void operator() (nano::object_stream &) const; -}; - class block { public: @@ -446,10 +383,6 @@ using block_uniquer = nano::uniquer; std::shared_ptr deserialize_block (nano::stream &); std::shared_ptr deserialize_block (nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); std::shared_ptr deserialize_block_json (boost::property_tree::ptree const &, nano::block_uniquer * = nullptr); -/** - * Serialize block type as an 8-bit value - */ -void serialize_block_type (nano::stream &, nano::block_type const &); /** * Serialize a block prefixed with an 8-bit typecode */ diff --git a/nano/store/block.hpp b/nano/store/block.hpp index 826aafc41c..c0d252a65a 100644 --- a/nano/store/block.hpp +++ b/nano/store/block.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include From 15979e856ebfab415051aa1176ed66f43028cdb2 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 03:13:22 +0000 Subject: [PATCH 143/190] Splitting block_uniquer in to its own file --- nano/lib/CMakeLists.txt | 1 + nano/lib/block_uniquer.hpp | 10 ++++++++++ nano/lib/blocks.hpp | 4 +--- nano/node/messages.hpp | 1 + nano/node/node.hpp | 1 + 5 files changed, 14 insertions(+), 3 deletions(-) create mode 100644 nano/lib/block_uniquer.hpp diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 9612fdf804..c7029af764 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -25,6 +25,7 @@ add_library( block_sideband.cpp block_type.hpp block_type.cpp + block_uniquer.hpp blockbuilders.hpp blockbuilders.cpp blocks.hpp diff --git a/nano/lib/block_uniquer.hpp b/nano/lib/block_uniquer.hpp new file mode 100644 index 0000000000..d39bb3afc4 --- /dev/null +++ b/nano/lib/block_uniquer.hpp @@ -0,0 +1,10 @@ +#pragma once + +#include +#include + +namespace nano +{ +class block; +using block_uniquer = nano::uniquer; +} diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 0fb5aee4ae..514adedfad 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -9,7 +10,6 @@ #include #include #include -#include #include #include @@ -378,8 +378,6 @@ class mutable_block_visitor virtual ~mutable_block_visitor () = default; }; -using block_uniquer = nano::uniquer; - std::shared_ptr deserialize_block (nano::stream &); std::shared_ptr deserialize_block (nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); std::shared_ptr deserialize_block_json (boost::property_tree::ptree const &, nano::block_uniquer * = nullptr); diff --git a/nano/node/messages.hpp b/nano/node/messages.hpp index 68d5d4247a..4e9401af20 100644 --- a/nano/node/messages.hpp +++ b/nano/node/messages.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 0776b72850..d4105e61e4 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include From 6f36c9790b185f684dc7e916ce9e85360acd3bba Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 02:16:01 +0000 Subject: [PATCH 144/190] Splitting db_val implementation for blocks in to its own template implementation file. --- nano/store/CMakeLists.txt | 1 + nano/store/db_val.hpp | 33 ++++++++------------------------- nano/store/db_val_impl.hpp | 33 +++++++++++++++++++++++++++++++++ nano/store/lmdb/block.cpp | 1 + nano/store/rocksdb/block.cpp | 1 + 5 files changed, 44 insertions(+), 25 deletions(-) create mode 100644 nano/store/db_val_impl.hpp diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt index a992ba59bc..bf79b03e34 100644 --- a/nano/store/CMakeLists.txt +++ b/nano/store/CMakeLists.txt @@ -5,6 +5,7 @@ add_library( component.hpp confirmation_height.hpp db_val.hpp + db_val_impl.hpp iterator.hpp iterator_impl.hpp final.hpp diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp index 957492e23e..a9fc4cc8d8 100644 --- a/nano/store/db_val.hpp +++ b/nano/store/db_val.hpp @@ -9,6 +9,11 @@ #include +namespace nano +{ +class block; +} + namespace nano::store { /** @@ -92,15 +97,7 @@ class db_val static_assert (std::is_standard_layout::value, "Standard layout is required"); } - db_val (std::shared_ptr const & val_a) : - buffer (std::make_shared> ()) - { - { - nano::vectorstream stream (*buffer); - nano::serialize_block (stream, *val_a); - } - convert_buffer_to_value (); - } + db_val (std::shared_ptr const & val_a); db_val (uint64_t val_a) : buffer (std::make_shared> ()) @@ -209,16 +206,7 @@ class db_val return result; } - explicit operator block_w_sideband () const - { - nano::bufferstream stream (reinterpret_cast (data ()), size ()); - nano::store::block_w_sideband block_w_sideband; - block_w_sideband.block = (nano::deserialize_block (stream)); - auto error = block_w_sideband.sideband.deserialize (stream, block_w_sideband.block->type ()); - release_assert (!error); - block_w_sideband.block->sideband_set (block_w_sideband.sideband); - return block_w_sideband; - } + explicit operator block_w_sideband () const; explicit operator std::nullptr_t () const { @@ -230,12 +218,7 @@ class db_val return no_value::dummy; } - explicit operator std::shared_ptr () const - { - nano::bufferstream stream (reinterpret_cast (data ()), size ()); - std::shared_ptr result (nano::deserialize_block (stream)); - return result; - } + explicit operator std::shared_ptr () const; template std::shared_ptr convert_to_block () const diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp new file mode 100644 index 0000000000..a8de6f0079 --- /dev/null +++ b/nano/store/db_val_impl.hpp @@ -0,0 +1,33 @@ +#include +#include + +template +nano::store::db_val::db_val (std::shared_ptr const & val_a) : + buffer (std::make_shared> ()) +{ + { + nano::vectorstream stream (*buffer); + nano::serialize_block (stream, *val_a); + } + convert_buffer_to_value (); +} + +template +nano::store::db_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (data ()), size ()); + std::shared_ptr result (nano::deserialize_block (stream)); + return result; +} + +template +nano::store::db_val::operator nano::store::block_w_sideband () const +{ + nano::bufferstream stream (reinterpret_cast (data ()), size ()); + nano::store::block_w_sideband block_w_sideband; + block_w_sideband.block = (nano::deserialize_block (stream)); + auto error = block_w_sideband.sideband.deserialize (stream, block_w_sideband.block->type ()); + release_assert (!error); + block_w_sideband.block->sideband_set (block_w_sideband.sideband); + return block_w_sideband; +} diff --git a/nano/store/lmdb/block.cpp b/nano/store/lmdb/block.cpp index ff6113f089..38e695ba66 100644 --- a/nano/store/lmdb/block.cpp +++ b/nano/store/lmdb/block.cpp @@ -1,4 +1,5 @@ #include +#include #include #include diff --git a/nano/store/rocksdb/block.cpp b/nano/store/rocksdb/block.cpp index 2fe5365e86..a910e0cc73 100644 --- a/nano/store/rocksdb/block.cpp +++ b/nano/store/rocksdb/block.cpp @@ -1,4 +1,5 @@ #include +#include #include #include From 08f70e9db5991e6ca046af510208ec5b0a481fbd Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 03:17:09 +0000 Subject: [PATCH 145/190] Forward declaring block and removing blocks.hpp includes from other headers. --- nano/core_test/active_transactions.cpp | 1 + nano/core_test/backlog.cpp | 1 + nano/core_test/block.cpp | 1 + nano/core_test/block_store.cpp | 1 + nano/core_test/blockprocessor.cpp | 1 + nano/core_test/bootstrap.cpp | 1 + nano/core_test/bootstrap_ascending.cpp | 1 + nano/core_test/bootstrap_server.cpp | 1 + nano/core_test/confirmation_height.cpp | 1 + nano/core_test/confirmation_solicitor.cpp | 1 + nano/core_test/conflicts.cpp | 2 +- nano/core_test/election.cpp | 1 + nano/core_test/election_scheduler.cpp | 1 + nano/core_test/frontiers_confirmation.cpp | 1 + nano/core_test/ledger.cpp | 1 + nano/core_test/memory_pool.cpp | 1 + nano/core_test/message.cpp | 1 + nano/core_test/message_deserializer.cpp | 1 + nano/core_test/network.cpp | 1 + nano/core_test/network_filter.cpp | 1 + nano/core_test/node.cpp | 1 + nano/core_test/optimistic_scheduler.cpp | 1 + nano/core_test/processor_service.cpp | 1 + nano/core_test/request_aggregator.cpp | 1 + nano/core_test/scheduler_buckets.cpp | 1 + nano/core_test/system.cpp | 1 + nano/core_test/unchecked_map.cpp | 1 + nano/core_test/vote_processor.cpp | 1 + nano/core_test/voting.cpp | 1 + nano/core_test/wallet.cpp | 1 + nano/core_test/wallets.cpp | 1 + nano/core_test/websocket.cpp | 1 + nano/lib/block_sideband.hpp | 1 + nano/lib/blockbuilders.cpp | 3 +++ nano/lib/blockbuilders.hpp | 11 ++++++++++- nano/lib/blocks.cpp | 6 ++++++ nano/lib/blocks.hpp | 2 -- nano/load_test/entry.cpp | 1 + nano/nano_node/entry.cpp | 1 + nano/node/active_transactions.cpp | 1 + nano/node/blockprocessor.cpp | 1 + nano/node/blockprocessor.hpp | 10 +++++++--- nano/node/bootstrap/block_deserializer.hpp | 4 +++- nano/node/bootstrap/bootstrap_attempt.cpp | 1 + nano/node/bootstrap/bootstrap_bulk_pull.cpp | 1 + nano/node/bootstrap/bootstrap_bulk_push.cpp | 1 + nano/node/bootstrap/bootstrap_frontier.hpp | 3 +++ nano/node/bootstrap/bootstrap_lazy.cpp | 1 + nano/node/bootstrap/bootstrap_server.cpp | 1 + nano/node/bootstrap_ascending/service.cpp | 1 + nano/node/cli.cpp | 1 + nano/node/confirmation_height_bounded.cpp | 1 + nano/node/confirmation_height_processor.cpp | 6 ++++++ nano/node/confirmation_height_processor.hpp | 5 +---- nano/node/confirmation_height_unbounded.cpp | 1 + nano/node/confirmation_solicitor.cpp | 1 + nano/node/election.cpp | 3 ++- nano/node/epoch_upgrader.cpp | 1 + nano/node/json_handler.cpp | 1 + nano/node/local_block_broadcaster.cpp | 8 +++++++- nano/node/local_block_broadcaster.hpp | 6 +----- nano/node/messages.hpp | 1 - nano/node/network.cpp | 1 + nano/node/node.cpp | 1 + nano/node/nodeconfig.cpp | 3 ++- nano/node/request_aggregator.cpp | 1 + nano/node/scheduler/optimistic.cpp | 1 + nano/node/scheduler/priority.cpp | 1 + nano/node/telemetry.cpp | 3 ++- nano/node/unchecked_map.cpp | 1 + nano/node/voting.cpp | 1 + nano/node/wallet.cpp | 1 + nano/node/websocket.cpp | 3 ++- nano/node/websocket.hpp | 2 +- nano/qt/qt.cpp | 1 + nano/qt_test/qt.cpp | 1 + nano/rpc_test/receivable.cpp | 1 + nano/rpc_test/rpc.cpp | 1 + nano/secure/common.cpp | 7 +------ nano/secure/common.hpp | 1 - nano/secure/ledger.cpp | 1 + nano/secure/network_filter.cpp | 1 + nano/secure/utility.cpp | 2 ++ nano/slow_test/node.cpp | 1 + nano/slow_test/vote_cache.cpp | 1 + nano/slow_test/vote_processor.cpp | 1 + nano/store/block.hpp | 2 +- nano/store/component.cpp | 1 + nano/store/lmdb/lmdb_env.cpp | 2 ++ nano/store/rocksdb/rocksdb.cpp | 1 + nano/store/versioning.hpp | 1 - nano/test_common/chains.cpp | 1 + nano/test_common/chains.hpp | 5 +++++ nano/test_common/ledger.cpp | 1 + nano/test_common/system.cpp | 1 + nano/test_common/testutil.cpp | 1 + 96 files changed, 139 insertions(+), 33 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index dc59f954f5..2b1bc50d0e 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/backlog.cpp b/nano/core_test/backlog.cpp index facbf0b538..fa58f702c6 100644 --- a/nano/core_test/backlog.cpp +++ b/nano/core_test/backlog.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 2b66920826..b187f63bbe 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 56f1c838f5..2b96b65b20 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/core_test/blockprocessor.cpp b/nano/core_test/blockprocessor.cpp index 38ccdc65b4..381cd1a915 100644 --- a/nano/core_test/blockprocessor.cpp +++ b/nano/core_test/blockprocessor.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index d1fbbb375a..27c78bb203 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index a9ca258454..257b35c60f 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/bootstrap_server.cpp b/nano/core_test/bootstrap_server.cpp index 9be0f8eb94..80abdd8001 100644 --- a/nano/core_test/bootstrap_server.cpp +++ b/nano/core_test/bootstrap_server.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 906c6bc2d2..b0d3c4169d 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index c47ae54e88..6cad122134 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 644388bdba..65ff27d1fd 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -1,4 +1,4 @@ - +#include #include #include #include diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index fc193cc659..d008489f12 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index af028dd996..b2af2740ba 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 76812a6bc7..9d476ed357 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index eb29e207d6..616324a6ab 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/memory_pool.cpp b/nano/core_test/memory_pool.cpp index 3e5049bc0c..1d9c1fc1b8 100644 --- a/nano/core_test/memory_pool.cpp +++ b/nano/core_test/memory_pool.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 102af44db8..3053bbf04c 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/core_test/message_deserializer.cpp b/nano/core_test/message_deserializer.cpp index 271330491e..44e9fa06df 100644 --- a/nano/core_test/message_deserializer.cpp +++ b/nano/core_test/message_deserializer.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index e6a514b9ad..2e15d5ef9d 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp index ae7f47e836..a886ae9564 100644 --- a/nano/core_test/network_filter.cpp +++ b/nano/core_test/network_filter.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index fa999b31bc..28dcae3dd9 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/optimistic_scheduler.cpp b/nano/core_test/optimistic_scheduler.cpp index 0f03c04fce..789eb66b3c 100644 --- a/nano/core_test/optimistic_scheduler.cpp +++ b/nano/core_test/optimistic_scheduler.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 9a9f33b10d..959495d1db 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index dff3215527..94f6d8c1b0 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/scheduler_buckets.cpp b/nano/core_test/scheduler_buckets.cpp index 0b3aff2381..43912e29b9 100644 --- a/nano/core_test/scheduler_buckets.cpp +++ b/nano/core_test/scheduler_buckets.cpp @@ -1,3 +1,4 @@ +#include #include #include diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 8ac65cc76b..b89524e8d2 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 3688b6f5e0..105ee31318 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index c19a895347..1da68596e8 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index cc95dd8461..cf210e3a1d 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 3c9802c633..079eb007c4 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 38009cdb19..f624f70dea 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 317d999e74..0735b5e4d6 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/lib/block_sideband.hpp b/nano/lib/block_sideband.hpp index dc7e8a428e..871f9bfcfc 100644 --- a/nano/lib/block_sideband.hpp +++ b/nano/lib/block_sideband.hpp @@ -7,6 +7,7 @@ #include #include +#include namespace nano { diff --git a/nano/lib/blockbuilders.cpp b/nano/lib/blockbuilders.cpp index 69b375eb11..d8fa600f8f 100644 --- a/nano/lib/blockbuilders.cpp +++ b/nano/lib/blockbuilders.cpp @@ -1,4 +1,7 @@ #include +#include +#include +#include #include diff --git a/nano/lib/blockbuilders.hpp b/nano/lib/blockbuilders.hpp index 077d584019..1471c9bb20 100644 --- a/nano/lib/blockbuilders.hpp +++ b/nano/lib/blockbuilders.hpp @@ -1,9 +1,18 @@ #pragma once -#include +#include #include +namespace nano +{ +class change_block; +class send_block; +class state_block; +class open_block; +class receive_block; +} + namespace nano { /** Flags to track builder state */ diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 0ad893339d..688e614d13 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -13,6 +13,12 @@ #include #include +size_t constexpr nano::send_block::size; +size_t constexpr nano::receive_block::size; +size_t constexpr nano::open_block::size; +size_t constexpr nano::change_block::size; +size_t constexpr nano::state_block::size; + /** Compare blocks, first by type, then content. This is an optimization over dynamic_cast, which is very slow on some platforms. */ namespace { diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 514adedfad..0cb6969ca0 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -83,8 +83,6 @@ class block virtual void operator() (nano::object_stream &) const; }; -using block_list_t = std::vector>; - class send_hashables { public: diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index e41e376abc..13f56e38c0 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 744df8d63b..42a79a8a2a 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 585bb4280b..2545c5d41d 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 24ed806777..731a000f76 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index 3cc7663c21..f0dae027c5 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include @@ -10,6 +9,13 @@ #include #include +namespace nano +{ +class block; +class node; +class write_database_queue; +} + namespace nano::store { class write_transaction; @@ -17,8 +23,6 @@ class write_transaction; namespace nano { -class node; -class write_database_queue; enum class block_source { diff --git a/nano/node/bootstrap/block_deserializer.hpp b/nano/node/bootstrap/block_deserializer.hpp index 9e53aa7903..98499200de 100644 --- a/nano/node/bootstrap/block_deserializer.hpp +++ b/nano/node/bootstrap/block_deserializer.hpp @@ -1,6 +1,8 @@ #pragma once -#include +#include + +#include #include #include diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 4057dd8e0e..390d502674 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 276e64418c..cad42863be 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index 5ff069ba12..8a1e81118d 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/bootstrap/bootstrap_frontier.hpp b/nano/node/bootstrap/bootstrap_frontier.hpp index 1f6575cd0f..75ee9c1ab9 100644 --- a/nano/node/bootstrap/bootstrap_frontier.hpp +++ b/nano/node/bootstrap/bootstrap_frontier.hpp @@ -1,7 +1,10 @@ #pragma once +#include + #include #include +#include namespace nano { diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index d69916a9c9..2c524c3f65 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 5585212fd8..91ba1838bd 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 1ab1362849..909d643a29 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index bc829fcbb5..984f1656f4 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 26cc21b42c..53c3ffbf30 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index 4b9d9d82a6..e60816444a 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -239,3 +240,8 @@ nano::block_hash nano::confirmation_height_processor::current () const nano::lock_guard lk (mutex); return original_block ? original_block->hash () : 0; } + +std::reference_wrapper nano::confirmation_height_processor::block_wrapper::hash () const +{ + return block->hash (); +} diff --git a/nano/node/confirmation_height_processor.hpp b/nano/node/confirmation_height_processor.hpp index d31267833f..828a616111 100644 --- a/nano/node/confirmation_height_processor.hpp +++ b/nano/node/confirmation_height_processor.hpp @@ -65,10 +65,7 @@ class confirmation_height_processor final { } - std::reference_wrapper hash () const - { - return block->hash (); - } + std::reference_wrapper hash () const; std::shared_ptr block; }; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 18c1e0dc28..03c4c42a24 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp index cece99c530..feb782453a 100644 --- a/nano/node/confirmation_solicitor.cpp +++ b/nano/node/confirmation_solicitor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/election.cpp b/nano/node/election.cpp index d967201d27..d01d3718bd 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -801,4 +802,4 @@ void nano::election_extended_status::operator() (nano::object_stream & obs) cons obs.write ("hash", block->hash ().to_string ()); obs.write ("amount", amount); }); -} \ No newline at end of file +} diff --git a/nano/node/epoch_upgrader.cpp b/nano/node/epoch_upgrader.cpp index 9072b53291..48007b3559 100644 --- a/nano/node/epoch_upgrader.cpp +++ b/nano/node/epoch_upgrader.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index ec02593e0e..16344c4cb7 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/local_block_broadcaster.cpp b/nano/node/local_block_broadcaster.cpp index 0e5097e59e..59c0e4dffd 100644 --- a/nano/node/local_block_broadcaster.cpp +++ b/nano/node/local_block_broadcaster.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -167,4 +168,9 @@ std::unique_ptr nano::local_block_broadcaster::c auto composite = std::make_unique (name); composite->add_component (std::make_unique (container_info{ "local", local_blocks.size (), sizeof (decltype (local_blocks)::value_type) })); return composite; -} \ No newline at end of file +} + +nano::block_hash nano::local_block_broadcaster::local_entry::hash () const +{ + return block->hash (); +} diff --git a/nano/node/local_block_broadcaster.hpp b/nano/node/local_block_broadcaster.hpp index 486fe85512..b4e7093dd6 100644 --- a/nano/node/local_block_broadcaster.hpp +++ b/nano/node/local_block_broadcaster.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include #include @@ -66,10 +65,7 @@ class local_block_broadcaster std::chrono::steady_clock::time_point const arrival; mutable std::chrono::steady_clock::time_point last_broadcast{}; // Not part of any index - nano::block_hash hash () const - { - return block->hash (); - } + nano::block_hash hash () const; }; // clang-format off diff --git a/nano/node/messages.hpp b/nano/node/messages.hpp index 4e9401af20..11d96d6bad 100644 --- a/nano/node/messages.hpp +++ b/nano/node/messages.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 0c9cf2268c..5da1940e00 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/node/node.cpp b/nano/node/node.cpp index b202b8b018..77651c6b52 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 175d78477b..beb93cb4f4 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -560,4 +561,4 @@ nano::account nano::node_config::random_representative () const std::size_t index (nano::random_pool::generate_word32 (0, static_cast (preconfigured_representatives.size () - 1))); auto result (preconfigured_representatives[index]); return result; -} \ No newline at end of file +} diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index 452f0e0ba0..f822ace915 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/scheduler/optimistic.cpp b/nano/node/scheduler/optimistic.cpp index bd5247957f..8672d976e1 100644 --- a/nano/node/scheduler/optimistic.cpp +++ b/nano/node/scheduler/optimistic.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index c503601a93..f5525895a0 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/telemetry.cpp b/nano/node/telemetry.cpp index e1fe6ece98..5e5b15fd2f 100644 --- a/nano/node/telemetry.cpp +++ b/nano/node/telemetry.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -439,4 +440,4 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector (version_fragments[4]); return consolidated_data; -} \ No newline at end of file +} diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index b20651d793..4d65a40d2f 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index 9ea31745d8..9967f7edb5 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index e1c2d7a834..53380f4b39 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index c2b3af2f98..dbd16637ab 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -1078,4 +1079,4 @@ void nano::websocket_server::stop () { server->stop (); } -} \ No newline at end of file +} diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 6bb7426a0b..4b58bae7f2 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include #include @@ -20,6 +19,7 @@ namespace nano { +class block; class wallets; class logger; class vote; diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index efd112cd7b..e189c58555 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -1,3 +1,4 @@ +#include #include #include diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 3f1972bd16..6ff9e931f6 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 81563180d0..6582161694 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index da0b1af1ae..f6fe1b0651 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index d34f9daf07..091e45fcc4 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -17,12 +18,6 @@ #include #include -size_t constexpr nano::send_block::size; -size_t constexpr nano::receive_block::size; -size_t constexpr nano::open_block::size; -size_t constexpr nano::change_block::size; -size_t constexpr nano::state_block::size; - nano::networks nano::network_constants::active_network = nano::networks::ACTIVE_NETWORK; namespace diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 2e183267d4..9ce6858258 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index d7464f4e07..92f76a4055 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/secure/network_filter.cpp b/nano/secure/network_filter.cpp index 059cddb30e..c60a111749 100644 --- a/nano/secure/network_filter.cpp +++ b/nano/secure/network_filter.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp index d7e263d81f..07d6472462 100644 --- a/nano/secure/utility.cpp +++ b/nano/secure/utility.cpp @@ -2,6 +2,8 @@ #include #include +#include + #include static std::vector all_unique_paths; diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index b9b8e4ed40..7aa3a4d34d 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/slow_test/vote_cache.cpp b/nano/slow_test/vote_cache.cpp index 3c4a7ccb40..1e0b4abae8 100644 --- a/nano/slow_test/vote_cache.cpp +++ b/nano/slow_test/vote_cache.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/slow_test/vote_processor.cpp b/nano/slow_test/vote_processor.cpp index ff1ae1f52d..4dc3c09992 100644 --- a/nano/slow_test/vote_processor.cpp +++ b/nano/slow_test/vote_processor.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/store/block.hpp b/nano/store/block.hpp index c0d252a65a..ad1fd55916 100644 --- a/nano/store/block.hpp +++ b/nano/store/block.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include #include @@ -10,6 +9,7 @@ namespace nano { +class block; class block_hash; } namespace nano::store diff --git a/nano/store/component.cpp b/nano/store/component.cpp index cd68dc2a09..67826f6345 100644 --- a/nano/store/component.cpp +++ b/nano/store/component.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/store/lmdb/lmdb_env.cpp b/nano/store/lmdb/lmdb_env.cpp index e66511da4c..cd1897c80a 100644 --- a/nano/store/lmdb/lmdb_env.cpp +++ b/nano/store/lmdb/lmdb_env.cpp @@ -1,6 +1,8 @@ #include #include +#include + nano::store::lmdb::env::env (bool & error_a, std::filesystem::path const & path_a, nano::store::lmdb::env::options options_a) { init (error_a, path_a, options_a); diff --git a/nano/store/rocksdb/rocksdb.cpp b/nano/store/rocksdb/rocksdb.cpp index 099972583c..43b82f2b4c 100644 --- a/nano/store/rocksdb/rocksdb.cpp +++ b/nano/store/rocksdb/rocksdb.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/store/versioning.hpp b/nano/store/versioning.hpp index 0160535345..b165eef7dc 100644 --- a/nano/store/versioning.hpp +++ b/nano/store/versioning.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include struct MDB_val; diff --git a/nano/test_common/chains.cpp b/nano/test_common/chains.cpp index e7a745a33f..9bc2fa99ed 100644 --- a/nano/test_common/chains.cpp +++ b/nano/test_common/chains.cpp @@ -1,3 +1,4 @@ +#include #include using namespace std::chrono_literals; diff --git a/nano/test_common/chains.hpp b/nano/test_common/chains.hpp index 2004159cac..f8fd4229df 100644 --- a/nano/test_common/chains.hpp +++ b/nano/test_common/chains.hpp @@ -8,6 +8,11 @@ #include #include +namespace nano +{ +using block_list_t = std::vector>; +} + /* * Helper functions to deal with common chain setup scenarios */ diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index 063000f33e..a4c91533d2 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 3ba0ce0009..efbd13dd44 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 9d6d5bb76e..ac01bdf0e7 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include From 4ad900ec31abf5245a50da65f30038742479fb27 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 03:11:40 +0000 Subject: [PATCH 146/190] Reduce header files within blocks.hpp --- nano/lib/blocks.hpp | 9 +++------ nano/lib/config.cpp | 1 + nano/lib/work.cpp | 1 + 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 0cb6969ca0..e89f2dddba 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -1,26 +1,23 @@ #pragma once -#include #include #include +#include #include #include #include -#include #include #include -#include -#include -#include #include -#include +typedef struct blake2b_state__ blake2b_state; namespace nano { class block_visitor; class mutable_block_visitor; +class object_stream; class block { diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index 7f40e3b039..1839d7412e 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 480dba578c..90a74095ae 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -1,3 +1,4 @@ +#include #include #include #include From 950c1848f3ccc03088eed83bf957234c7e3ab306 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 7 Mar 2024 12:35:07 +0000 Subject: [PATCH 147/190] Minor unused test code bugfix (nano::test::account_height) (#4466) No test is currently using this function but it is useful function --- nano/test_common/testutil.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 9d6d5bb76e..fcdd79e6d0 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -289,7 +289,7 @@ uint64_t nano::test::account_height (nano::node const & node, nano::account cons { auto const tx = node.ledger.store.tx_begin_read (); nano::confirmation_height_info height_info; - if (!node.ledger.store.confirmation_height.get (tx, acc, height_info)) + if (node.ledger.store.confirmation_height.get (tx, acc, height_info)) { return 0; } From e7f28c6a92a5d6f4dc5321b995f38c2bce394608 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 7 Mar 2024 13:44:32 +0000 Subject: [PATCH 148/190] Rep crawler test case for having 2 reps inside one node --- nano/core_test/rep_crawler.cpp | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 85f4ba1811..3bebc0754c 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -269,4 +270,28 @@ TEST (rep_crawler, ignore_local) auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); node.rep_crawler.force_process (vote, loopback); ASSERT_ALWAYS_EQ (0.5s, node.rep_crawler.representative_count (), 0); +} + +// Test that nodes can track PRs when multiple PRs are inside one node +TEST (rep_crawler, two_reps_one_node) +{ + nano::test::system system; + auto & node1 = *system.add_node (); + auto & node2 = *system.add_node (); + + // create a second PR account + nano::keypair second_rep = nano::test::setup_rep (system, node1, node1.balance (nano::dev::genesis_key.pub) / 10); + ASSERT_EQ (0, node2.rep_crawler.representative_count ()); + + // enable the two PRs in node1 + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + system.wallet (0)->insert_adhoc (second_rep.prv); + + ASSERT_TIMELY_EQ (5s, node2.rep_crawler.representative_count (), 2); + auto reps = node2.rep_crawler.representatives (); + ASSERT_EQ (2, reps.size ()); + + // check that the reps are correct + ASSERT_TRUE (nano::dev::genesis_key.pub == reps[0].account || nano::dev::genesis_key.pub == reps[1].account); + ASSERT_TRUE (second_rep.pub == reps[0].account || second_rep.pub == reps[1].account); } \ No newline at end of file From eb55b98ad74aa0b746d598f5f71866797da8d7c6 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 7 Mar 2024 13:58:35 +0000 Subject: [PATCH 149/190] rep_query_interval needs to be faster for dev network --- nano/node/repcrawler.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 7934370b2a..a196749ccf 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -228,7 +228,7 @@ std::vector> nano::rep_crawler::prepar constexpr std::size_t aggressive_count = 160; constexpr std::size_t conservative_max_attempts = 4; constexpr std::size_t aggressive_max_attempts = 8; - constexpr std::chrono::seconds rep_query_interval = std::chrono::seconds{ 60 }; + std::chrono::milliseconds rep_query_interval = node.network_params.network.is_dev_network () ? std::chrono::milliseconds{ 500 } : std::chrono::milliseconds{ 60 * 1000 }; stats.inc (nano::stat::type::rep_crawler, sufficient_weight ? nano::stat::detail::crawl_normal : nano::stat::detail::crawl_aggressive); From 62fb8ffbd0ce4c334dd47bc9248d60e6f1a79782 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 7 Mar 2024 14:03:51 +0000 Subject: [PATCH 150/190] Fix rep tracking when there are multiple reps inside one node Do not delete the query when a confirm_ack is received with the right vote. We might get more replies and we have no way of knowing how many will come. Just let the query timeout. --- nano/node/repcrawler.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index a196749ccf..9898bfdc7e 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -401,7 +401,6 @@ bool nano::rep_crawler::process (std::shared_ptr const & vote, std:: // TODO: Track query response time responses.push_back ({ channel, vote }); - queries.erase (it); condition.notify_all (); return true; // Found and processed From 4f2f66bbe2356ffc84da779106b879f28186f94e Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Thu, 7 Mar 2024 15:14:52 +0000 Subject: [PATCH 151/190] Do not complain when a query timeout, if replies were received --- nano/lib/stats_enums.hpp | 1 + nano/node/repcrawler.cpp | 16 +++++++++++++--- nano/node/repcrawler.hpp | 1 + 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index edad231fd5..a6bf2a5d4d 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -337,6 +337,7 @@ enum class detail : uint8_t query_duplicate, rep_timeout, query_timeout, + query_completion, crawl_aggressive, crawl_normal, diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 9898bfdc7e..ebe3e88104 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -211,8 +211,16 @@ void nano::rep_crawler::cleanup () erase_if (queries, [this] (query_entry const & query) { if (nano::elapsed (query.time, config.query_timeout)) { - logger.debug (nano::log::type::rep_crawler, "Aborting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); - stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_timeout); + if (query.replies == 0) + { + logger.debug (nano::log::type::rep_crawler, "Aborting unresponsive query for block {} from {}", query.hash.to_string (), query.channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_timeout); + } + else + { + logger.debug (nano::log::type::rep_crawler, "Completion of query with {} replies for block {} from {}", query.replies, query.hash.to_string (), query.channel->to_string ()); + stats.inc (nano::stat::type::rep_crawler, nano::stat::detail::query_completion); + } return true; // Erase } return false; @@ -401,7 +409,9 @@ bool nano::rep_crawler::process (std::shared_ptr const & vote, std:: // TODO: Track query response time responses.push_back ({ channel, vote }); - + queries.modify (it, [] (query_entry & e) { + e.replies++; + }); condition.notify_all (); return true; // Found and processed } diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 6e74cf3c54..e850b8f68a 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -141,6 +141,7 @@ class rep_crawler final nano::block_hash hash; std::shared_ptr channel; std::chrono::steady_clock::time_point time{ std::chrono::steady_clock::now () }; + unsigned int replies{ 0 }; // number of replies to the query }; // clang-format off From 254aa88dc14bdccfe303f9d819d609ab844e26ec Mon Sep 17 00:00:00 2001 From: cuinix <65650185+cuinix@users.noreply.github.com> Date: Thu, 7 Mar 2024 23:38:50 +0800 Subject: [PATCH 152/190] fix some typos in docs (#4467) Signed-off-by: cuinix <915115094@qq.com> --- CL/cl2.hpp | 6 +++--- boost_checkout_lite.sh | 4 ++-- nano/core_test/confirmation_height.cpp | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/CL/cl2.hpp b/CL/cl2.hpp index 534c486988..d4f1b51b64 100644 --- a/CL/cl2.hpp +++ b/CL/cl2.hpp @@ -3571,19 +3571,19 @@ cl::pointer>> allocate_svm(const cl } #endif // #if !defined(CL_HPP_NO_STD_UNIQUE_PTR) -/*! \brief Vector alias to simplify contruction of coarse-grained SVM containers. +/*! \brief Vector alias to simplify construction of coarse-grained SVM containers. * */ template < class T > using coarse_svm_vector = vector>>; -/*! \brief Vector alias to simplify contruction of fine-grained SVM containers. +/*! \brief Vector alias to simplify construction of fine-grained SVM containers. * */ template < class T > using fine_svm_vector = vector>>; -/*! \brief Vector alias to simplify contruction of fine-grained SVM containers that support platform atomics. +/*! \brief Vector alias to simplify construction of fine-grained SVM containers that support platform atomics. * */ template < class T > diff --git a/boost_checkout_lite.sh b/boost_checkout_lite.sh index 6e650ce7ab..18fe59588f 100755 --- a/boost_checkout_lite.sh +++ b/boost_checkout_lite.sh @@ -9,11 +9,11 @@ git submodule init boost cd boost # deactivate all boost submodules git submodule foreach 'git config submodule.$sm_path.active false' -# selectivly activate required dependencies +# selectively activate required dependencies for i in ${dependencies[@]} do git config submodule.$i.active true done cd .. -# Update all submodules recursivly. Deactivated modules will be skipped by --recursive +# Update all submodules recursively. Deactivated modules will be skipped by --recursive git submodule update --jobs 16 --recursive --recommend-shallow --single-branch diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index b0d3c4169d..52723aaebd 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1279,7 +1279,7 @@ TEST (confirmation_heightDeathTest, modified_chain) ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { - // This reads the blocks in the account, but prevents any writes from occuring yet + // This reads the blocks in the account, but prevents any writes from occurring yet auto scoped_write_guard = write_database_queue.wait (nano::writer::testing); bounded_processor.process (send); } @@ -1298,7 +1298,7 @@ TEST (confirmation_heightDeathTest, modified_chain) ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { - // This reads the blocks in the account, but prevents any writes from occuring yet + // This reads the blocks in the account, but prevents any writes from occurring yet auto scoped_write_guard = write_database_queue.wait (nano::writer::testing); unbounded_processor.process (send); } @@ -1367,7 +1367,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { - // This reads the blocks in the account, but prevents any writes from occuring yet + // This reads the blocks in the account, but prevents any writes from occurring yet auto scoped_write_guard = write_database_queue.wait (nano::writer::testing); unbounded_processor.process (open); } @@ -1387,7 +1387,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); { - // This reads the blocks in the account, but prevents any writes from occuring yet + // This reads the blocks in the account, but prevents any writes from occurring yet auto scoped_write_guard = write_database_queue.wait (nano::writer::testing); bounded_processor.process (open); } From 5678e8ccb75b8489d465d95b92957bf94177b61c Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 15:03:43 +0000 Subject: [PATCH 153/190] Directly use genesis_key.pub for obtaining the genesis account, rather than querying the genesis block. --- nano/core_test/block_store.cpp | 6 +- nano/core_test/bootstrap.cpp | 12 +- nano/core_test/confirmation_height.cpp | 56 +-- nano/core_test/ledger.cpp | 644 ++++++++++++------------- nano/core_test/node.cpp | 12 +- nano/core_test/system.cpp | 14 +- nano/core_test/wallet.cpp | 66 +-- nano/core_test/wallets.cpp | 12 +- nano/load_test/entry.cpp | 2 +- nano/qt_test/qt.cpp | 6 +- nano/rpc_test/receivable.cpp | 2 +- nano/rpc_test/rpc.cpp | 126 ++--- nano/slow_test/node.cpp | 8 +- nano/test_common/system.cpp | 2 +- 14 files changed, 484 insertions(+), 484 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 2b96b65b20..08e267716f 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -383,7 +383,7 @@ TEST (block_store, genesis) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger_cache, nano::dev::constants); nano::account_info info; - ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info)); ASSERT_EQ (nano::dev::genesis->hash (), info.head); auto block1 (store->block.get (transaction, info.head)); ASSERT_NE (nullptr, block1); @@ -393,13 +393,13 @@ TEST (block_store, genesis) ASSERT_EQ (info.block_count, 1); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); auto dev_pub_text (nano::dev::genesis_key.pub.to_string ()); auto dev_pub_account (nano::dev::genesis_key.pub.to_account ()); auto dev_prv_text (nano::dev::genesis_key.prv.to_string ()); - ASSERT_EQ (nano::dev::genesis->account (), nano::dev::genesis_key.pub); + ASSERT_EQ (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub); } TEST (block_store, empty_accounts) diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 27c78bb203..57aeae26fc 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -159,7 +159,7 @@ TEST (bulk_pull, ascending_two_account) auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); - req->start = nano::dev::genesis->account (); + req->start = nano::dev::genesis_key.pub; req->end.clear (); req->header.flag_set (nano::message_header::bulk_pull_ascending_flag); auto request = std::make_shared (connection, std::move (req)); @@ -2123,9 +2123,9 @@ TEST (bulk_pull_account, basics) nano::keypair key1; system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key1.prv); - auto send1 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 25)); - auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10)); - auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2)); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 25)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 10)); + auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 2)); ASSERT_TIMELY_EQ (5s, system.nodes[0]->balance (key1.pub), 25); auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); @@ -2143,7 +2143,7 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_EQ (send2->hash (), block_data.first.get ()->hash); ASSERT_EQ (nano::uint128_union (10), block_data.second.get ()->amount); - ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis_key.pub, block_data.second.get ()->source); ASSERT_EQ (nullptr, request->get_next ().first.get ()); } @@ -2157,7 +2157,7 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_NE (nullptr, block_data.first.get ()); ASSERT_NE (nullptr, block_data.second.get ()); - ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis_key.pub, block_data.second.get ()->source); block_data = request->get_next (); ASSERT_EQ (nullptr, block_data.first.get ()); ASSERT_EQ (nullptr, block_data.second.get ()); diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 52723aaebd..db2e46fd0b 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -133,7 +133,7 @@ TEST (confirmation_height, multiple_accounts) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -141,7 +141,7 @@ TEST (confirmation_height, multiple_accounts) auto open2 = builder .open () .source (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key2.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) @@ -149,7 +149,7 @@ TEST (confirmation_height, multiple_accounts) auto open3 = builder .open () .source (send3->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key3.pub) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3.pub)) @@ -320,9 +320,9 @@ TEST (confirmation_height, gap_bootstrap) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -331,9 +331,9 @@ TEST (confirmation_height, gap_bootstrap) node1.work_generate_blocking (*send1); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -342,9 +342,9 @@ TEST (confirmation_height, gap_bootstrap) node1.work_generate_blocking (*send2); auto send3 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -453,9 +453,9 @@ TEST (confirmation_height, gap_live) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 1) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -464,9 +464,9 @@ TEST (confirmation_height, gap_live) node->work_generate_blocking (*send1); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 2) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -475,9 +475,9 @@ TEST (confirmation_height, gap_live) node->work_generate_blocking (*send2); auto send3 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 3) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -593,7 +593,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -601,7 +601,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) auto send2 = builder .send () .previous (open1->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (1000) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) @@ -609,7 +609,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) auto send3 = builder .send () .previous (send2->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (900) .sign (key1.prv, key1.pub) .work (*system.work.generate (send2->hash ())) @@ -617,7 +617,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) auto send4 = builder .send () .previous (send3->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (500) .sign (key1.prv, key1.pub) .work (*system.work.generate (send3->hash ())) @@ -1013,9 +1013,9 @@ TEST (confirmation_height, all_block_types) .build (); auto state_receive3 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2 + 1) .link (state_send4->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1292,7 +1292,7 @@ TEST (confirmation_heightDeathTest, modified_chain) } ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), send)); - store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis_key.pub, { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -1381,7 +1381,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) // Reset conditions and test with the bounded processor ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), open)); - store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis_key.pub, { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( ledger, write_database_queue, 10ms, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -1663,7 +1663,7 @@ TEST (confirmation_height, cemented_gap_below_receive) auto open = builder .open () .source (send->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -1722,7 +1722,7 @@ TEST (confirmation_height, cemented_gap_below_receive) auto open1 = builder .open () .source (send3->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key2.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) @@ -1823,7 +1823,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) auto open = builder .open () .source (send->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -1882,7 +1882,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) auto open1 = builder .open () .source (send3->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key2.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) @@ -1910,7 +1910,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) // Force some blocks to be cemented so that the cached confirmed info variable is empty { auto transaction (node->store.tx_begin_write ()); - node->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 3, send1->hash () }); + node->store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, nano::confirmation_height_info{ 3, send1->hash () }); node->store.confirmation_height.put (transaction, key1.pub, nano::confirmation_height_info{ 2, receive1->hash () }); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index ac26b842be..9b776a165a 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -46,9 +46,9 @@ TEST (ledger, genesis_balance) auto & ledger = ctx.ledger (); auto & store = ctx.store (); auto transaction = store.tx_begin_write (); - auto balance = ledger.account_balance (transaction, nano::dev::genesis->account ()); + auto balance = ledger.account_balance (transaction, nano::dev::genesis_key.pub); ASSERT_EQ (nano::dev::constants.genesis_amount, balance); - auto info = ledger.account_info (transaction, nano::dev::genesis->account ()); + auto info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info); ASSERT_EQ (1, ledger.cache.account_count); // Frontier time should have been updated when genesis balance was added @@ -56,7 +56,7 @@ TEST (ledger, genesis_balance) ASSERT_LT (nano::seconds_since_epoch () - info->modified, 10); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); } @@ -70,11 +70,11 @@ TEST (ledger, process_modifies_sideband) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -497,7 +497,7 @@ TEST (ledger, weight) { auto ctx = nano::test::context::ledger_empty (); auto & ledger = ctx.ledger (); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); } TEST (ledger, representative_change) @@ -2275,7 +2275,7 @@ TEST (ledger, block_destination_source) auto block2 = builder .send () .previous (block1->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (balance) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) @@ -2291,9 +2291,9 @@ TEST (ledger, block_destination_source) balance -= nano::Gxrb_ratio; auto block4 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (block3->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (dest.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2302,20 +2302,20 @@ TEST (ledger, block_destination_source) balance -= nano::Gxrb_ratio; auto block5 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (block4->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (balance) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block4->hash ())) .build (); balance += nano::Gxrb_ratio; auto block6 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (block5->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (block5->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2330,13 +2330,13 @@ TEST (ledger, block_destination_source) ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); ASSERT_TRUE (ledger.block_source (transaction, *block1).is_zero ()); - ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, *block2)); + ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block2)); ASSERT_TRUE (ledger.block_source (transaction, *block2).is_zero ()); ASSERT_EQ (ledger.block_destination (transaction, *block3), nullptr); ASSERT_EQ (block2->hash (), ledger.block_source (transaction, *block3)); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block4)); ASSERT_TRUE (ledger.block_source (transaction, *block4).is_zero ()); - ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, *block5)); + ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block5)); ASSERT_TRUE (ledger.block_source (transaction, *block5).is_zero ()); ASSERT_EQ (ledger.block_destination (transaction, *block6), nullptr); ASSERT_EQ (block5->hash (), ledger.block_source (transaction, *block6)); @@ -2352,16 +2352,16 @@ TEST (ledger, state_account) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1->hash ())); + ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (transaction, send1->hash ())); } TEST (ledger, state_send_receive) @@ -2374,11 +2374,11 @@ TEST (ledger, state_send_receive) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2389,17 +2389,17 @@ TEST (ledger, state_send_receive) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); ASSERT_FALSE (send2->sideband ().details.is_receive); ASSERT_FALSE (send2->sideband ().details.is_epoch); auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2412,8 +2412,8 @@ TEST (ledger, state_send_receive) ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); - ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); @@ -2432,7 +2432,7 @@ TEST (ledger, state_receive) auto send1 = builder .send () .previous (nano::dev::genesis->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) @@ -2444,12 +2444,12 @@ TEST (ledger, state_receive) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2462,7 +2462,7 @@ TEST (ledger, state_receive) ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -2480,7 +2480,7 @@ TEST (ledger, state_rep_change) nano::block_builder builder; auto change1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount) @@ -2495,7 +2495,7 @@ TEST (ledger, state_rep_change) ASSERT_EQ (*change1, *change2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, change1->hash ())); ASSERT_EQ (0, ledger.amount (transaction, change1->hash ())); - ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); ASSERT_FALSE (change2->sideband ().details.is_send); @@ -2514,9 +2514,9 @@ TEST (ledger, state_open) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2529,13 +2529,13 @@ TEST (ledger, state_open) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); auto open1 = builder .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (destination.prv, destination.pub) @@ -2549,7 +2549,7 @@ TEST (ledger, state_open) ASSERT_EQ (*open1, *open2); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (ledger.cache.account_count, store.account.count (transaction)); ASSERT_EQ (1, open2->sideband ().height); ASSERT_FALSE (open2->sideband ().details.is_send); @@ -2568,11 +2568,11 @@ TEST (ledger, send_after_state_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2580,7 +2580,7 @@ TEST (ledger, send_after_state_fail) auto send2 = builder .send () .previous (send1->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - (2 * nano::Gxrb_ratio)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) @@ -2599,11 +2599,11 @@ TEST (ledger, receive_after_state_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2629,11 +2629,11 @@ TEST (ledger, change_after_state_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2660,7 +2660,7 @@ TEST (ledger, state_unreceivable_fail) auto send1 = builder .send () .previous (nano::dev::genesis->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) @@ -2672,12 +2672,12 @@ TEST (ledger, state_unreceivable_fail) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2697,7 +2697,7 @@ TEST (ledger, state_receive_bad_amount_fail) auto send1 = builder .send () .previous (nano::dev::genesis->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) @@ -2709,12 +2709,12 @@ TEST (ledger, state_receive_bad_amount_fail) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2733,11 +2733,11 @@ TEST (ledger, state_no_link_amount_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2745,7 +2745,7 @@ TEST (ledger, state_no_link_amount_fail) nano::keypair rep; auto change1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount) @@ -2766,11 +2766,11 @@ TEST (ledger, state_receive_wrong_account_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2781,13 +2781,13 @@ TEST (ledger, state_receive_wrong_account_fail) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair key; auto receive1 = builder .state () .account (key.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (key.prv, key.pub) @@ -2807,9 +2807,9 @@ TEST (ledger, state_open_state_fork) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2820,7 +2820,7 @@ TEST (ledger, state_open_state_fork) .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (destination.prv, destination.pub) @@ -2830,7 +2830,7 @@ TEST (ledger, state_open_state_fork) auto open2 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -2850,9 +2850,9 @@ TEST (ledger, state_state_open_fork) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2862,7 +2862,7 @@ TEST (ledger, state_state_open_fork) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -2872,7 +2872,7 @@ TEST (ledger, state_state_open_fork) .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (destination.prv, destination.pub) @@ -2894,9 +2894,9 @@ TEST (ledger, state_open_previous_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2907,7 +2907,7 @@ TEST (ledger, state_open_previous_fail) .state () .account (destination.pub) .previous (1) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (destination.prv, destination.pub) @@ -2927,9 +2927,9 @@ TEST (ledger, state_open_source_fail) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2940,7 +2940,7 @@ TEST (ledger, state_open_source_fail) .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (0) .link (0) .sign (destination.prv, destination.pub) @@ -2960,11 +2960,11 @@ TEST (ledger, state_send_change) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -2975,7 +2975,7 @@ TEST (ledger, state_send_change) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); @@ -2993,11 +2993,11 @@ TEST (ledger, state_receive_change) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -3008,11 +3008,11 @@ TEST (ledger, state_receive_change) ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair rep; auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount) @@ -3027,7 +3027,7 @@ TEST (ledger, state_receive_change) ASSERT_EQ (*receive1, *receive2); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); - ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); @@ -3046,9 +3046,9 @@ TEST (ledger, state_open_old) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3058,7 +3058,7 @@ TEST (ledger, state_open_old) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -3066,7 +3066,7 @@ TEST (ledger, state_open_old) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); } TEST (ledger, state_receive_old) @@ -3080,9 +3080,9 @@ TEST (ledger, state_receive_old) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3091,9 +3091,9 @@ TEST (ledger, state_receive_old) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - (2 * nano::Gxrb_ratio)) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3103,7 +3103,7 @@ TEST (ledger, state_receive_old) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -3119,7 +3119,7 @@ TEST (ledger, state_receive_old) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); } TEST (ledger, state_rollback_send) @@ -3132,11 +3132,11 @@ TEST (ledger, state_rollback_send) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -3145,17 +3145,17 @@ TEST (ledger, state_rollback_send) auto send2 = ledger.block (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); ASSERT_EQ (*send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); + auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info); - ASSERT_EQ (nano::dev::genesis->account (), info->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); - ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_TRUE (store.block.successor (transaction, nano::dev::genesis->hash ()).is_zero ()); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -3170,35 +3170,35 @@ TEST (ledger, state_rollback_receive) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); + ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); - auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info); - ASSERT_EQ (nano::dev::genesis->account (), info->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -3213,9 +3213,9 @@ TEST (ledger, state_rollback_received_send) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3233,13 +3233,13 @@ TEST (ledger, state_rollback_received_send) .work (*pool.generate (key.pub)) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); + ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); - ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); ASSERT_EQ (0, ledger.weight (key.pub)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); @@ -3256,7 +3256,7 @@ TEST (ledger, state_rep_change_rollback) nano::block_builder builder; auto change1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount) @@ -3267,8 +3267,8 @@ TEST (ledger, state_rep_change_rollback) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, change1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (rep.pub)); } @@ -3283,9 +3283,9 @@ TEST (ledger, state_open_rollback) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3296,7 +3296,7 @@ TEST (ledger, state_open_rollback) .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::Gxrb_ratio) .link (send1->hash ()) .sign (destination.prv, destination.pub) @@ -3306,10 +3306,10 @@ TEST (ledger, state_open_rollback) ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, open1->hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); auto info = ledger.pending_info (transaction, nano::pending_key (destination.pub, send1->hash ())); ASSERT_TRUE (info); - ASSERT_EQ (nano::dev::genesis->account (), info->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -3325,19 +3325,19 @@ TEST (ledger, state_send_change_rollback) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (rep.pub)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -3352,11 +3352,11 @@ TEST (ledger, state_receive_change_rollback) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -3364,7 +3364,7 @@ TEST (ledger, state_receive_change_rollback) nano::keypair rep; auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (rep.pub) .balance (nano::dev::constants.genesis_amount) @@ -3375,8 +3375,8 @@ TEST (ledger, state_receive_change_rollback) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); ASSERT_FALSE (ledger.block_exists (transaction, receive1->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (rep.pub)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -3392,9 +3392,9 @@ TEST (ledger, epoch_blocks_v1_general) nano::block_builder builder; auto epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3408,24 +3408,24 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks auto epoch2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch2)); - auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + auto genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); ASSERT_FALSE (ledger.rollback (transaction, epoch1->hash ())); - genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); - genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); ASSERT_FALSE (epoch1->sideband ().details.is_send); @@ -3436,16 +3436,16 @@ TEST (ledger, epoch_blocks_v1_general) auto change1 = builder .change () .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3460,7 +3460,7 @@ TEST (ledger, epoch_blocks_v1_general) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -3470,7 +3470,7 @@ TEST (ledger, epoch_blocks_v1_general) .state () .account (destination.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (0) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3517,7 +3517,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (0, ledger.balance (transaction, epoch4->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -3535,9 +3535,9 @@ TEST (ledger, epoch_blocks_v2_general) nano::block_builder builder; auto epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3548,9 +3548,9 @@ TEST (ledger, epoch_blocks_v2_general) // Set it to the first epoch and it should now succeed epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3561,9 +3561,9 @@ TEST (ledger, epoch_blocks_v2_general) ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks auto epoch2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3574,39 +3574,39 @@ TEST (ledger, epoch_blocks_v2_general) ASSERT_EQ (nano::epoch::epoch_0, epoch2->sideband ().source_epoch); // Not used for epoch blocks auto epoch3 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch3)); - auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + auto genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_2); ASSERT_FALSE (ledger.rollback (transaction, epoch1->hash ())); - genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); - genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); + genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); auto change1 = builder .change () .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3618,7 +3618,7 @@ TEST (ledger, epoch_blocks_v2_general) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (destination.pub) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) @@ -3641,7 +3641,7 @@ TEST (ledger, epoch_blocks_v2_general) .state () .account (destination.pub) .previous (epoch4->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (0) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3685,7 +3685,7 @@ TEST (ledger, epoch_blocks_v2_general) ASSERT_EQ (0, ledger.balance (transaction, epoch6->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2->hash ())); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); } @@ -3700,9 +3700,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3711,9 +3711,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3722,9 +3722,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3808,9 +3808,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) nano::keypair destination3; auto epoch2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3819,9 +3819,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch2)); auto send4 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) .link (destination3.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3840,9 +3840,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) // Send it to an epoch 1 account auto send5 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send4->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3872,9 +3872,9 @@ TEST (ledger, epoch_blocks_receive_upgrade) nano::keypair destination4; auto send6 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send5->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5) .link (destination4.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3917,9 +3917,9 @@ TEST (ledger, epoch_blocks_fork) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3928,9 +3928,9 @@ TEST (ledger, epoch_blocks_fork) ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch1)); auto epoch2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3939,9 +3939,9 @@ TEST (ledger, epoch_blocks_fork) ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch2)); auto epoch3 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -3952,9 +3952,9 @@ TEST (ledger, epoch_blocks_fork) ASSERT_EQ (nano::epoch::epoch_0, epoch3->sideband ().source_epoch); // Not used for epoch state blocks auto epoch4 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_2)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4057,9 +4057,9 @@ TEST (ledger, epoch_open_pending) ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ()); // New block to process epoch open auto send1 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4083,9 +4083,9 @@ TEST (ledger, block_hash_account_conflict) * in the ledger and not an account */ auto send1 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4095,7 +4095,7 @@ TEST (ledger, block_hash_account_conflict) auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -4111,7 +4111,7 @@ TEST (ledger, block_hash_account_conflict) auto send2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (90) .link (receive1->hash ()) .sign (key1.prv, key1.pub) @@ -4167,9 +4167,9 @@ TEST (ledger, unchecked_epoch) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4227,9 +4227,9 @@ TEST (ledger, unchecked_epoch_invalid) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4309,9 +4309,9 @@ TEST (ledger, unchecked_open) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4361,9 +4361,9 @@ TEST (ledger, unchecked_receive) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4372,9 +4372,9 @@ TEST (ledger, unchecked_receive) node1.work_generate_blocking (*send1); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4444,17 +4444,17 @@ TEST (ledger, confirmation_height_not_updated) .work (*pool.generate (account_info->head)) .build (); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key.pub) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) @@ -4597,9 +4597,9 @@ TEST (ledger, dependents_confirmed) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4608,9 +4608,9 @@ TEST (ledger, dependents_confirmed) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 200) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4621,7 +4621,7 @@ TEST (ledger, dependents_confirmed) auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -4630,14 +4630,14 @@ TEST (ledger, dependents_confirmed) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, height)); height.height += 1; - ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1)); auto receive2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (200) .link (send2->hash ()) .sign (key1.prv, key1.pub) @@ -4649,9 +4649,9 @@ TEST (ledger, dependents_confirmed) height.height += 1; ledger.store.confirmation_height.put (transaction, key1.pub, height); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, height)); height.height += 1; - ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive2)); } @@ -4669,9 +4669,9 @@ TEST (ledger, dependents_confirmed_pruning) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4679,9 +4679,9 @@ TEST (ledger, dependents_confirmed_pruning) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 200) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4689,15 +4689,15 @@ TEST (ledger, dependents_confirmed_pruning) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, height)); height.height = 3; - ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); ASSERT_EQ (2, ledger.pruning_action (transaction, send2->hash (), 1)); auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -4717,9 +4717,9 @@ TEST (ledger, block_confirmed) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4730,9 +4730,9 @@ TEST (ledger, block_confirmed) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, height)); ++height.height; - ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); } @@ -4760,16 +4760,16 @@ TEST (ledger, cache) ASSERT_EQ (account_count, cache_a.account_count); ASSERT_EQ (block_count, cache_a.block_count); ASSERT_EQ (cemented_count, cache_a.cemented_count); - ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::dev::genesis->account ())); + ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (pruned_count, cache_a.pruned_count); }; nano::keypair key; - auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis->account ()); + auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis_key.pub); auto send = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - (i + 1)) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4807,10 +4807,10 @@ TEST (ledger, cache) { auto transaction (store.tx_begin_write ()); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, height)); ++height.height; height.frontier = send->hash (); - ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, height); ASSERT_TRUE (ledger.block_confirmed (transaction, send->hash ())); ++ledger.cache.cemented_count; } @@ -4859,11 +4859,11 @@ TEST (ledger, pruning_action) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -4872,14 +4872,14 @@ TEST (ledger, pruning_action) auto send1_stored (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send1_stored); ASSERT_EQ (*send1, *send1_stored); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); @@ -4888,7 +4888,7 @@ TEST (ledger, pruning_action) // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); ASSERT_EQ (0, ledger.pruning_action (transaction, nano::dev::genesis->hash (), 1)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1->hash ())); // Pruned ledger start without proper flags emulation @@ -4901,9 +4901,9 @@ TEST (ledger, pruning_action) // Receiving pruned block auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4914,7 +4914,7 @@ TEST (ledger, pruning_action) auto receive1_stored (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive1_stored); ASSERT_EQ (*receive1, *receive1_stored); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (4, receive1_stored->sideband ().height); ASSERT_FALSE (receive1_stored->sideband ().details.is_send); ASSERT_TRUE (receive1_stored->sideband ().details.is_receive); @@ -4947,11 +4947,11 @@ TEST (ledger, pruning_large_chain) { auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (last_hash) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (last_hash)) .build (); @@ -4959,9 +4959,9 @@ TEST (ledger, pruning_large_chain) ASSERT_TRUE (store->block.exists (transaction, send->hash ())); auto receive = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (send->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4998,9 +4998,9 @@ TEST (ledger, pruning_source_rollback) nano::block_builder builder; auto epoch1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -5009,23 +5009,23 @@ TEST (ledger, pruning_source_rollback) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (epoch1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); @@ -5038,36 +5038,36 @@ TEST (ledger, pruning_source_rollback) ASSERT_FALSE (store->block.exists (transaction, epoch1->hash ())); ASSERT_TRUE (store->pruned.exists (transaction, epoch1->hash ())); ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); - auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info); - ASSERT_EQ (nano::dev::genesis->account (), info->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info->source); ASSERT_EQ (nano::Gxrb_ratio, info->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info->epoch); // Receiving pruned block auto receive1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); - auto info2 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + auto info2 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info2); - ASSERT_NE (nano::dev::genesis->account (), info2->source); // Tradeoff to not store pruned blocks accounts + ASSERT_NE (nano::dev::genesis_key.pub, info2->source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2->epoch); // Process receive block again ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); } @@ -5087,13 +5087,13 @@ TEST (ledger, pruning_source_rollback_legacy) auto send1 = builder .send () .previous (nano::dev::genesis->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); nano::keypair key1; auto send2 = builder .send () @@ -5109,14 +5109,14 @@ TEST (ledger, pruning_source_rollback_legacy) auto send3 = builder .send () .previous (send2->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); ASSERT_TRUE (store->block.exists (transaction, send3->hash ())); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send3->hash ()))); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send2->hash (), 1)); ASSERT_FALSE (store->block.exists (transaction, send2->hash ())); @@ -5124,14 +5124,14 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); ASSERT_TRUE (store->pruned.exists (transaction, send1->hash ())); ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); - auto info1 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + auto info1 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info1); - ASSERT_EQ (nano::dev::genesis->account (), info1->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info1->source); ASSERT_EQ (nano::Gxrb_ratio, info1->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info1->epoch); auto info2 = ledger.pending_info (transaction, nano::pending_key (key1.pub, send2->hash ())); ASSERT_TRUE (info2); - ASSERT_EQ (nano::dev::genesis->account (), info2->source); + ASSERT_EQ (nano::dev::genesis_key.pub, info2->source); ASSERT_EQ (nano::Gxrb_ratio, info2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info2->epoch); // Receiving pruned block @@ -5143,26 +5143,26 @@ TEST (ledger, pruning_source_rollback_legacy) .work (*pool.generate (send3->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); - auto info3 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); + auto info3 = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ())); ASSERT_TRUE (info3); - ASSERT_NE (nano::dev::genesis->account (), info3->source); // Tradeoff to not store pruned blocks accounts + ASSERT_NE (nano::dev::genesis_key.pub, info3->source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info3->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3->epoch); // Process receive block again ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Receiving pruned block (open) auto open1 = builder .open () .source (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) @@ -5175,7 +5175,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); auto info4 = ledger.pending_info (transaction, nano::pending_key (key1.pub, send2->hash ())); ASSERT_TRUE (info4); - ASSERT_NE (nano::dev::genesis->account (), info4->source); // Tradeoff to not store pruned blocks accounts + ASSERT_NE (nano::dev::genesis_key.pub, info4->source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info4->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4->epoch); // Process open block again @@ -5199,11 +5199,11 @@ TEST (ledger, pruning_process_error) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -5219,11 +5219,11 @@ TEST (ledger, pruning_process_error) // Attept to process new block after pruned auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); @@ -5248,13 +5248,13 @@ TEST (ledger, pruning_legacy_blocks) auto send1 = builder .send () .previous (nano::dev::genesis->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -5283,7 +5283,7 @@ TEST (ledger, pruning_legacy_blocks) auto open1 = builder .open () .source (send2->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) @@ -5292,7 +5292,7 @@ TEST (ledger, pruning_legacy_blocks) auto send3 = builder .send () .previous (open1->hash ()) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (0) .sign (key1.prv, key1.pub) .work (*pool.generate (open1->hash ())) @@ -5332,11 +5332,11 @@ TEST (ledger, pruning_safe_functions) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -5344,11 +5344,11 @@ TEST (ledger, pruning_safe_functions) ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); @@ -5366,7 +5366,7 @@ TEST (ledger, pruning_safe_functions) ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance (transaction, send2->hash ()).value ()); ASSERT_FALSE (ledger.amount (transaction, send2->hash ())); ASSERT_FALSE (ledger.account (transaction, send1->hash ())); - ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send2->hash ()).value ()); + ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (transaction, send2->hash ()).value ()); } TEST (ledger, hash_root_random) @@ -5383,11 +5383,11 @@ TEST (ledger, hash_root_random) nano::block_builder builder; auto send1 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); @@ -5395,11 +5395,11 @@ TEST (ledger, hash_root_random) ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); @@ -5461,13 +5461,13 @@ TEST (ledger, migrate_lmdb_to_rocksdb) ASSERT_FALSE (store.init_error ()); // Lower the database to the max version unsupported for upgrades - store.confirmation_height.put (transaction, nano::dev::genesis->account (), { 2, send->hash () }); + store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, { 2, send->hash () }); store.online_weight.put (transaction, 100, nano::amount (2)); store.frontier.put (transaction, nano::block_hash (2), nano::account (5)); store.peer.put (transaction, endpoint_key); - store.pending.put (transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), nano::pending_info (nano::dev::genesis->account (), 100, nano::epoch::epoch_0)); + store.pending.put (transaction, nano::pending_key (nano::dev::genesis_key.pub, send->hash ()), nano::pending_info (nano::dev::genesis_key.pub, 100, nano::epoch::epoch_0)); store.pruned.put (transaction, send->hash ()); store.version.put (transaction, version); send->sideband_set ({}); @@ -5482,7 +5482,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) auto rocksdb_transaction (rocksdb_store.tx_begin_read ()); nano::pending_info pending_info{}; - ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), pending_info)); + ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis_key.pub, send->hash ()), pending_info)); for (auto i = rocksdb_store.online_weight.begin (rocksdb_transaction); i != rocksdb_store.online_weight.end (); ++i) { @@ -5499,7 +5499,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) ASSERT_EQ (rocksdb_store.version.get (rocksdb_transaction), version); ASSERT_EQ (rocksdb_store.frontier.get (rocksdb_transaction, 2), 5); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (rocksdb_store.confirmation_height.get (rocksdb_transaction, nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (rocksdb_store.confirmation_height.get (rocksdb_transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 2); ASSERT_EQ (confirmation_height_info.frontier, send->hash ()); ASSERT_EQ (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ())).size (), 1); @@ -5518,11 +5518,11 @@ TEST (ledger, unconfirmed_frontiers) nano::state_block_builder builder; nano::keypair key; - auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis->account ()); + auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis_key.pub); auto send = builder.make_block () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - 100) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -5534,7 +5534,7 @@ TEST (ledger, unconfirmed_frontiers) unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); ASSERT_EQ (unconfirmed_frontiers.begin ()->first, 1); - nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::dev::genesis->account () }; + nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::dev::genesis_key.pub }; auto uncemented_info2 = unconfirmed_frontiers.begin ()->second; ASSERT_EQ (uncemented_info1.account, uncemented_info2.account); ASSERT_EQ (uncemented_info1.cemented_frontier, uncemented_info2.cemented_frontier); @@ -5576,5 +5576,5 @@ TEST (ledger, head_block) auto & ledger = ctx.ledger (); auto & store = ctx.store (); auto tx = store.tx_begin_read (); - ASSERT_EQ (*nano::dev::genesis, *ledger.head_block (tx, nano::dev::genesis->account ())); + ASSERT_EQ (*nano::dev::genesis, *ledger.head_block (tx, nano::dev::genesis_key.pub)); } diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 28dcae3dd9..c4b600f0e6 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1567,7 +1567,7 @@ TEST (node, unconfirmed_send) // firstly, send two units from node1 to node2 and expect that both nodes see the block as confirmed // (node1 will start an election for it, vote on it and node2 gets synced up) - auto send1 = wallet1->send_action (nano::dev::genesis->account (), key2.pub, 2 * nano::Mxrb_ratio); + auto send1 = wallet1->send_action (nano::dev::genesis_key.pub, key2.pub, 2 * nano::Mxrb_ratio); ASSERT_TIMELY (5s, node1.block_confirmed (send1->hash ())); ASSERT_TIMELY (5s, node2.block_confirmed (send1->hash ())); @@ -1583,19 +1583,19 @@ TEST (node, unconfirmed_send) .previous (recv1->hash ()) .representative (nano::dev::genesis_key.pub) .balance (nano::Mxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (key2.prv, key2.pub) .work (*system.work.generate (recv1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, node2.process (send2)); - auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio); + auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis_key.pub, nano::Mxrb_ratio); ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ())); ASSERT_TIMELY (5s, node1.block_confirmed (send2->hash ())); ASSERT_TIMELY (5s, node2.block_confirmed (send3->hash ())); ASSERT_TIMELY (5s, node1.block_confirmed (send3->hash ())); ASSERT_TIMELY_EQ (5s, node2.ledger.cache.cemented_count, 7); - ASSERT_TIMELY_EQ (5s, node1.balance (nano::dev::genesis->account ()), nano::dev::constants.genesis_amount); + ASSERT_TIMELY_EQ (5s, node1.balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount); } // Test that nodes can track nodes that have rep weight for priority broadcasting @@ -2567,9 +2567,9 @@ TEST (node, DISABLED_vote_by_hash_epoch_block_republish) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto epoch1 = nano::state_block_builder () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index b89524e8d2..9fd8912483 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -31,7 +31,7 @@ TEST (system, system_genesis) for (auto & i : system.nodes) { auto transaction (i->store.tx_begin_read ()); - ASSERT_EQ (nano::dev::constants.genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis_key.pub)); } } @@ -42,7 +42,7 @@ TEST (system, DISABLED_generate_send_existing) nano::thread_runner runner (system.io_ctx, node1.config.io_threads); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); auto info1 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub); ASSERT_TRUE (info1); std::vector accounts; @@ -55,7 +55,7 @@ TEST (system, DISABLED_generate_send_existing) auto open_block = builder .open () .source (send_block->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (stake_preserver.pub) .sign (stake_preserver.prv, stake_preserver.pub) .work (0) @@ -63,7 +63,7 @@ TEST (system, DISABLED_generate_send_existing) node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis_key.pub)); auto info2 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub); ASSERT_TRUE (info2); ASSERT_NE (info1->head, info2->head); @@ -99,14 +99,14 @@ TEST (system, DISABLED_generate_send_new) ASSERT_EQ (node1.store.account.end (), iterator1); } nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); { auto transaction (node1.store.tx_begin_write ()); nano::block_builder builder; auto open_block = builder .open () .source (send_block->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (stake_preserver.pub) .sign (stake_preserver.prv, stake_preserver.pub) .work (0) @@ -114,7 +114,7 @@ TEST (system, DISABLED_generate_send_new) node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis_key.pub)); std::vector accounts; accounts.push_back (nano::dev::genesis_key.pub); // This indirectly waits for online weight to stabilize, required to prevent intermittent failures diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 079eb007c4..ab107d56a4 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -17,7 +17,7 @@ TEST (wallet, no_special_keys_accounts) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -38,7 +38,7 @@ TEST (wallet, no_key) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::keypair key1; nano::raw_key prv1; @@ -53,7 +53,7 @@ TEST (wallet, fetch_locked) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_TRUE (wallet.valid_password (transaction)); nano::keypair key1; ASSERT_EQ (key1.pub, wallet.insert_adhoc (transaction, key1.prv)); @@ -75,7 +75,7 @@ TEST (wallet, retrieval) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_TRUE (wallet.valid_password (transaction)); @@ -97,7 +97,7 @@ TEST (wallet, empty_iteration) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); auto i (wallet.begin (transaction)); auto j (wallet.end ()); @@ -111,7 +111,7 @@ TEST (wallet, one_item_iteration) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::keypair key1; wallet.insert_adhoc (transaction, key1.prv); @@ -139,7 +139,7 @@ TEST (wallet, two_item_iteration) nano::kdf kdf{ nano::dev::network_params.kdf_work }; { auto transaction (env.tx_begin_write ()); - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); wallet.insert_adhoc (transaction, key1.prv); wallet.insert_adhoc (transaction, key2.prv); @@ -259,7 +259,7 @@ TEST (wallet, find_none) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::account account (1000); ASSERT_EQ (wallet.end (), wallet.find (transaction, account)); @@ -272,7 +272,7 @@ TEST (wallet, find_existing) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -291,7 +291,7 @@ TEST (wallet, rekey) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::raw_key password; wallet.password.value (password); @@ -363,7 +363,7 @@ TEST (wallet, hash_password) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); nano::raw_key hash1; wallet.derive_key (hash1, transaction, ""); @@ -413,25 +413,25 @@ TEST (wallet, reopen_default_password) ASSERT_FALSE (init); nano::kdf kdf{ nano::dev::network_params.kdf_work }; { - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); wallet.rekey (transaction, ""); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (init); ASSERT_FALSE (wallet.valid_password (transaction)); wallet.attempt_password (transaction, " "); @@ -448,10 +448,10 @@ TEST (wallet, representative) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (error); ASSERT_FALSE (wallet.is_representative (transaction)); - ASSERT_EQ (nano::dev::genesis->account (), wallet.representative (transaction)); + ASSERT_EQ (nano::dev::genesis_key.pub, wallet.representative (transaction)); ASSERT_FALSE (wallet.is_representative (transaction)); nano::keypair key; wallet.representative_set (transaction, key.pub); @@ -469,11 +469,11 @@ TEST (wallet, serialize_json_empty) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (error); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -494,13 +494,13 @@ TEST (wallet, serialize_json_one) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -523,14 +523,14 @@ TEST (wallet, serialize_json_password) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.rekey (transaction, "password"); wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "1", serialized); ASSERT_FALSE (error); ASSERT_FALSE (wallet2.valid_password (transaction)); ASSERT_FALSE (wallet2.attempt_password (transaction, "password")); @@ -556,11 +556,11 @@ TEST (wallet_store, move) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); ASSERT_FALSE (error); nano::keypair key1; wallet1.insert_adhoc (transaction, key1.prv); - nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis->account (), 1, "1"); + nano::wallet_store wallet2 (error, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "1"); ASSERT_FALSE (error); nano::keypair key2; wallet2.insert_adhoc (transaction, key2.prv); @@ -714,7 +714,7 @@ TEST (wallet, deterministic_keys) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); auto key1 = wallet.deterministic_key (transaction, 0); auto key2 = wallet.deterministic_key (transaction, 0); ASSERT_EQ (key1, key2); @@ -757,7 +757,7 @@ TEST (wallet, reseed) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis->account (), 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, env, nano::dev::genesis_key.pub, 1, "0"); nano::raw_key seed1; seed1 = 1; nano::raw_key seed2; @@ -1155,11 +1155,11 @@ TEST (wallet, search_receivable) wallet.insert_adhoc (nano::dev::genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ()) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); @@ -1172,7 +1172,7 @@ TEST (wallet, search_receivable) ASSERT_TIMELY (5s, election = node.active.election (send->qualified_root ())); // Erase the key so the confirmation does not trigger an automatic receive - wallet.store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); + wallet.store.erase (node.wallets.tx_begin_write (), nano::dev::genesis_key.pub); // Now confirm the election election->force_confirm (); @@ -1185,8 +1185,8 @@ TEST (wallet, search_receivable) // Pending search should create the receive block ASSERT_EQ (2, node.ledger.cache.block_count); ASSERT_FALSE (wallet.search_receivable (wallet.wallets.tx_begin_read ())); - ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis->account ()), nano::dev::constants.genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); + ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis_key.pub); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index f624f70dea..bbff7d287d 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -205,11 +205,11 @@ TEST (wallets, search_receivable) wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ()) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); @@ -229,7 +229,7 @@ TEST (wallets, search_receivable) ASSERT_TIMELY (5s, election = node.active.election (send->qualified_root ())); // Erase the key so the confirmation does not trigger an automatic receive - wallet->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); + wallet->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis_key.pub); // Now confirm the election election->force_confirm (); @@ -249,8 +249,8 @@ TEST (wallets, search_receivable) { node.wallets.search_receivable (wallet_id); } - ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis->account ()), nano::dev::constants.genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); + ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis_key.pub); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index 13f56e38c0..7a012fdeb0 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -653,7 +653,7 @@ int main (int argc, char * const * argv) } // Send from genesis account to different accounts and receive the funds - auto send_receive = std::make_shared (ioc, wallet, nano::dev::genesis->account ().to_account (), destination_account->as_string, send_calls_remaining, primary_node_results); + auto send_receive = std::make_shared (ioc, wallet, nano::dev::genesis_key.pub.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results); boost::asio::strand strand{ ioc.get_executor () }; boost::asio::post (strand, [send_receive] () { diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 6ff9e931f6..313378e0fe 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -360,7 +360,7 @@ TEST (wallet, DISABLED_process_block) nano_qt::eventloop_processor processor; nano::test::system system (1); nano::account account; - nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis_key.pub)); system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->wallets.tx_begin_read ()); @@ -665,7 +665,7 @@ TEST (wallet, block_viewer) ASSERT_NE (-1, wallet->advanced.layout->indexOf (wallet->advanced.block_viewer)); QTest::mouseClick (wallet->advanced.block_viewer, Qt::LeftButton); ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); - nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis_key.pub)); QTest::keyClicks (wallet->block_viewer.hash, latest.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.retrieve, Qt::LeftButton); ASSERT_FALSE (wallet->block_viewer.block->toPlainText ().toStdString ().empty ()); @@ -916,7 +916,7 @@ TEST (wallet, DISABLED_synchronizing) wallet->start (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); + auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send = std::make_shared (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); system1.nodes[0]->ledger.process (transaction, send); } diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 6582161694..236165745e 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -197,7 +197,7 @@ TEST (rpc, receivable_offset_and_sorting) // check confirmation height is as expected, there is no perfect clarity yet when confirmation height updates after a block get confirmed nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height.get (node->store.tx_begin_read (), nano::dev::genesis->account (), confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (node->store.tx_begin_read (), nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 7); ASSERT_EQ (confirmation_height_info.frontier, block6->hash ()); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index f6fe1b0651..bbd88b8fa6 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -505,7 +505,7 @@ TEST (rpc, wallet_representative) request.put ("action", "wallet_representative"); auto response (wait_response (system, rpc_ctx, request)); std::string account_text1 (response.get ("representative")); - ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); + ASSERT_EQ (account_text1, nano::dev::genesis_key.pub.to_account ()); } TEST (rpc, wallet_representative_set) @@ -663,7 +663,7 @@ TEST (rpc, wallet_export) bool error (false); auto transaction (node->wallets.tx_begin_write ()); nano::kdf kdf{ nano::dev::network_params.kdf_work }; - nano::wallet_store store (error, kdf, transaction, node->wallets.env, nano::dev::genesis->account (), 1, "0", wallet_json); + nano::wallet_store store (error, kdf, transaction, node->wallets.env, nano::dev::genesis_key.pub, 1, "0", wallet_json); ASSERT_FALSE (error); ASSERT_TRUE (store.exists (transaction, nano::dev::genesis_key.pub)); } @@ -718,7 +718,7 @@ TEST (rpc, block) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block"); - request.put ("hash", node->latest (nano::dev::genesis->account ()).to_string ()); + request.put ("hash", node->latest (nano::dev::genesis_key.pub).to_string ()); auto response (wait_response (system, rpc_ctx, request)); auto contents (response.get ("contents")); ASSERT_FALSE (contents.empty ()); @@ -928,19 +928,19 @@ TEST (rpc, history) nano::block_builder builder; auto usend = builder .state () - .account (nano::dev::genesis->account ()) - .previous (node0->latest (nano::dev::genesis->account ())) - .representative (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) + .previous (node0->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))) + .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis_key.pub))) .build (); auto ureceive = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (usend->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (usend->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -948,7 +948,7 @@ TEST (rpc, history) .build (); auto uchange = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (ureceive->hash ()) .representative (nano::keypair ().pub) .balance (nano::dev::constants.genesis_amount) @@ -1012,19 +1012,19 @@ TEST (rpc, account_history) nano::block_builder builder; auto usend = builder .state () - .account (nano::dev::genesis->account ()) - .previous (node0->latest (nano::dev::genesis->account ())) - .representative (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) + .previous (node0->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))) + .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis_key.pub))) .build (); auto ureceive = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (usend->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (usend->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1032,7 +1032,7 @@ TEST (rpc, account_history) .build (); auto uchange = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (ureceive->hash ()) .representative (nano::keypair ().pub) .balance (nano::dev::constants.genesis_amount) @@ -1050,7 +1050,7 @@ TEST (rpc, account_history) { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::dev::genesis->account ().to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("count", 100); auto response (wait_response (system, rpc_ctx, request, 10s)); std::vector> history_l; @@ -1096,7 +1096,7 @@ TEST (rpc, account_history) { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::dev::genesis->account ().to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("reverse", true); request.put ("count", 1); auto response (wait_response (system, rpc_ctx, request, 10s)); @@ -1211,11 +1211,11 @@ TEST (rpc, history_pruning) // non legacy self send auto usend = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (receive->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) - .link (nano::dev::genesis->account ()) + .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (receive->hash ())) .build (); @@ -1224,9 +1224,9 @@ TEST (rpc, history_pruning) // non legacy receive of the non legacy self send auto ureceive = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (usend->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount) .link (usend->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1237,7 +1237,7 @@ TEST (rpc, history_pruning) // change genesis to a random rep auto uchange = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (ureceive->hash ()) .representative (nano::keypair ().pub) .balance (nano::dev::constants.genesis_amount) @@ -1514,9 +1514,9 @@ TEST (rpc, process_subtype_send) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1550,9 +1550,9 @@ TEST (rpc, process_subtype_open) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1599,9 +1599,9 @@ TEST (rpc, process_subtype_receive) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -1652,9 +1652,9 @@ TEST (rpc, process_ledger_insufficient_work) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -2377,11 +2377,11 @@ TEST (rpc, account_representative) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; - request.put ("account", nano::dev::genesis->account ().to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("action", "account_representative"); auto response (wait_response (system, rpc_ctx, request)); std::string account_text1 (response.get ("representative")); - ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); + ASSERT_EQ (account_text1, nano::dev::genesis_key.pub.to_account ()); } TEST (rpc, account_representative_set) @@ -2429,7 +2429,7 @@ TEST (rpc, account_representative_set_work_disabled) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; nano::keypair rep; - request.put ("account", nano::dev::genesis->account ().to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("representative", rep.pub.to_account ()); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); @@ -2491,7 +2491,7 @@ TEST (rpc, bootstrap) auto send = builder .send () .previous (latest) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) @@ -2511,7 +2511,7 @@ TEST (rpc, bootstrap) system0.poll (); } system1.deadline_set (10s); - while (node->latest (nano::dev::genesis->account ()) != node1->latest (nano::dev::genesis->account ())) + while (node->latest (nano::dev::genesis_key.pub) != node1->latest (nano::dev::genesis_key.pub)) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); @@ -2550,7 +2550,7 @@ TEST (rpc, representatives) representatives.push_back (account); } ASSERT_EQ (1, representatives.size ()); - ASSERT_EQ (nano::dev::genesis->account (), representatives[0]); + ASSERT_EQ (nano::dev::genesis_key.pub, representatives[0]); } // wallet_seed is only available over IPC's unsafe encoding, and when running on test network @@ -2626,7 +2626,7 @@ TEST (rpc, wallet_frontiers) frontiers.push_back (nano::account (i->second.get (""))); } ASSERT_EQ (1, frontiers.size ()); - ASSERT_EQ (node->latest (nano::dev::genesis->account ()), frontiers[0]); + ASSERT_EQ (node->latest (nano::dev::genesis_key.pub), frontiers[0]); } TEST (rpc, work_validate) @@ -2776,7 +2776,7 @@ TEST (rpc, bootstrap_any) auto send = builder .send () .previous (latest) - .destination (nano::dev::genesis->account ()) + .destination (nano::dev::genesis_key.pub) .balance (100) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system1.nodes[0]->work_generate_blocking (latest)) @@ -3051,8 +3051,8 @@ TEST (rpc, accounts_representatives) request.add_child ("accounts", accounts); auto response (wait_response (system, rpc_ctx, request)); // Ensures the response is correct. - auto response_representative (response.get_child ("representatives").get (nano::dev::genesis->account ().to_account ())); - ASSERT_EQ (response_representative, nano::dev::genesis->account ().to_account ()); + auto response_representative (response.get_child ("representatives").get (nano::dev::genesis_key.pub.to_account ())); + ASSERT_EQ (response_representative, nano::dev::genesis_key.pub.to_account ()); ASSERT_EQ (response.count ("errors"), 0); } @@ -3093,7 +3093,7 @@ TEST (rpc, accounts_representatives_with_errors) ASSERT_EQ (response.get_child ("representatives").size (), 1); ASSERT_EQ (response.get_child ("representatives").count (nano::dev::genesis_key.pub.to_account ()), 1); auto rep_text = response.get_child ("representatives").get (nano::dev::genesis_key.pub.to_account ()); - ASSERT_EQ (rep_text, nano::dev::genesis->account ().to_account ()); + ASSERT_EQ (rep_text, nano::dev::genesis_key.pub.to_account ()); ASSERT_EQ (response.count ("errors"), 1); ASSERT_EQ (response.get_child ("errors").size (), 2); @@ -3126,7 +3126,7 @@ TEST (rpc, accounts_frontiers) ASSERT_EQ (response.get_child ("frontiers").size (), 1); ASSERT_EQ (response.get_child ("frontiers").count (nano::dev::genesis_key.pub.to_account ()), 1); auto frontier_text = response.get_child ("frontiers").get (nano::dev::genesis_key.pub.to_account ()); - ASSERT_EQ (nano::block_hash{ frontier_text }, node->latest (nano::dev::genesis->account ())); + ASSERT_EQ (nano::block_hash{ frontier_text }, node->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (response.count ("errors"), 0); } @@ -3166,7 +3166,7 @@ TEST (rpc, accounts_frontiers_with_errors) ASSERT_EQ (response.get_child ("frontiers").size (), 1); ASSERT_EQ (response.get_child ("frontiers").count (nano::dev::genesis_key.pub.to_account ()), 1); auto frontier_text = response.get_child ("frontiers").get (nano::dev::genesis_key.pub.to_account ()); - ASSERT_EQ (nano::block_hash{ frontier_text }, node->latest (nano::dev::genesis->account ())); + ASSERT_EQ (nano::block_hash{ frontier_text }, node->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (response.count ("errors"), 1); ASSERT_EQ (response.get_child ("errors").size (), 2); @@ -3185,14 +3185,14 @@ TEST (rpc, blocks) request.put ("action", "blocks"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); + entry.put ("", node->latest (nano::dev::genesis_key.pub).to_string ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("hashes", peers_l); auto response (wait_response (system, rpc_ctx, request)); for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis_key.pub).to_string (), hash_text); std::string blocks_text (blocks.second.get ("")); ASSERT_FALSE (blocks_text.empty ()); } @@ -3291,7 +3291,7 @@ TEST (rpc, pending_exists) auto node = add_ipc_enabled_node (system, config); nano::keypair key1; system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto hash0 (node->latest (nano::dev::genesis->account ())); + auto hash0 (node->latest (nano::dev::genesis_key.pub)); auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); ASSERT_TIMELY (5s, node->block_confirmed (block1->hash ())); ASSERT_TIMELY (5s, !node->active.active (*block1)); @@ -3467,7 +3467,7 @@ TEST (rpc, work_get) std::string work_text (response.get ("work")); uint64_t work (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis_key.pub, work); ASSERT_EQ (nano::to_string_hex (work), work_text); } @@ -3489,7 +3489,7 @@ TEST (rpc, wallet_work_get) ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string work_text (works.second.get ("")); uint64_t work (1); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis_key.pub, work); ASSERT_EQ (nano::to_string_hex (work), work_text); } } @@ -3511,7 +3511,7 @@ TEST (rpc, work_set) ASSERT_TRUE (success.empty ()); uint64_t work1 (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work1); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis_key.pub, work1); ASSERT_EQ (work1, work0); } @@ -3973,9 +3973,9 @@ TEST (rpc, json_block_input) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (node1->latest (nano::dev::genesis_key.pub)) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -4042,7 +4042,7 @@ TEST (rpc, blocks_info) for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis_key.pub).to_string (), hash_text); std::string account_text (blocks.second.get ("block_account")); ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string amount_text (blocks.second.get ("amount")); @@ -4066,7 +4066,7 @@ TEST (rpc, blocks_info) request.put ("action", "blocks_info"); boost::property_tree::ptree entry; boost::property_tree::ptree hashes; - entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); + entry.put ("", node->latest (nano::dev::genesis_key.pub).to_string ()); hashes.push_back (std::make_pair ("", entry)); request.add_child ("hashes", hashes); { @@ -5719,9 +5719,9 @@ TEST (rpc, sign_hash) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (node1->latest (nano::dev::genesis_key.pub)) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -5752,9 +5752,9 @@ TEST (rpc, sign_block) nano::block_builder builder; auto send = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (node1->latest (nano::dev::genesis_key.pub)) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -5855,7 +5855,7 @@ TEST (rpc, block_confirmed) auto open1 = builder .open () .source (send1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 7aa3a4d34d..0ac1ee294c 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -820,7 +820,7 @@ TEST (confirmation_height, long_chains) auto open = builder .open () .source (send->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .account (key1.pub) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -874,7 +874,7 @@ TEST (confirmation_height, long_chains) .state () .account (nano::dev::genesis_key.pub) .previous (previous_genesis_chain_hash) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + 1) .link (send1->hash ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) @@ -885,9 +885,9 @@ TEST (confirmation_height, long_chains) nano::keypair key2; auto send2 = builder .state () - .account (nano::dev::genesis->account ()) + .account (nano::dev::genesis_key.pub) .previous (receive1->hash ()) - .representative (nano::dev::genesis->account ()) + .representative (nano::dev::genesis_key.pub) .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) .link (key2.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index efbd13dd44..f7107d9bd5 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -422,7 +422,7 @@ void nano::test::system::generate_receive (nano::node & node_a) } if (send_block != nullptr) { - auto receive_error (wallet (0)->receive_sync (send_block, nano::dev::genesis->account (), std::numeric_limits::max ())); + auto receive_error (wallet (0)->receive_sync (send_block, nano::dev::genesis_key.pub, std::numeric_limits::max ())); (void)receive_error; } } From 76ebe9afa8c25d24d210b330b1467d68021192c5 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 15:39:50 +0000 Subject: [PATCH 154/190] Convert boost::optional to std::optional for distributed work generation. --- nano/core_test/distributed_work.cpp | 38 +++++++++++++------------- nano/core_test/node.cpp | 14 +++++----- nano/core_test/websocket.cpp | 4 +-- nano/node/distributed_work.cpp | 12 ++++---- nano/node/distributed_work.hpp | 8 ++++-- nano/node/distributed_work_factory.cpp | 2 +- nano/node/distributed_work_factory.hpp | 3 +- nano/node/json_handler.cpp | 8 +++--- nano/node/node.cpp | 22 +++++++-------- nano/node/node.hpp | 13 +++++---- nano/node/wallet.cpp | 6 ++-- nano/qt/qt.cpp | 8 +++--- nano/rpc_test/rpc.cpp | 14 +++++----- 13 files changed, 78 insertions(+), 74 deletions(-) diff --git a/nano/core_test/distributed_work.cpp b/nano/core_test/distributed_work.cpp index 115293bd6b..1e5e5ed4a8 100644 --- a/nano/core_test/distributed_work.cpp +++ b/nano/core_test/distributed_work.cpp @@ -18,10 +18,10 @@ TEST (distributed_work, no_peers) nano::test::system system (1); auto node (system.nodes[0]); nano::block_hash hash{ 1 }; - boost::optional work; + std::optional work; std::atomic done{ false }; - auto callback = [&work, &done] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&work, &done] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); work = work_a; done = true; }; @@ -54,8 +54,8 @@ TEST (distributed_work, no_peers_cancel) auto & node = *system.add_node (node_config); nano::block_hash hash{ 1 }; bool done{ false }; - auto callback_to_cancel = [&done] (boost::optional work_a) { - ASSERT_FALSE (work_a.is_initialized ()); + auto callback_to_cancel = [&done] (std::optional work_a) { + ASSERT_FALSE (work_a.has_value ()); done = true; }; ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.work.base), callback_to_cancel)); @@ -83,8 +83,8 @@ TEST (distributed_work, no_peers_multi) nano::block_hash hash{ 1 }; unsigned total{ 10 }; std::atomic count{ 0 }; - auto callback = [&count] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&count] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); ++count; }; // Test many works for the same root @@ -125,10 +125,10 @@ TEST (distributed_work, peer) auto node (system.add_node (node_config)); ASSERT_FALSE (node->local_work_generation_enabled ()); nano::block_hash hash{ 1 }; - boost::optional work; + std::optional work; std::atomic done{ false }; - auto callback = [&work, &done] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&work, &done] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); work = work_a; done = true; }; @@ -151,10 +151,10 @@ TEST (distributed_work, peer_malicious) auto node (system.nodes[0]); ASSERT_TRUE (node->local_work_generation_enabled ()); nano::block_hash hash{ 1 }; - boost::optional work; + std::optional work; std::atomic done{ false }; - auto callback = [&work, &done] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&work, &done] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); work = work_a; done = true; }; @@ -194,10 +194,10 @@ TEST (distributed_work, DISABLED_peer_multi) auto node (system.nodes[0]); ASSERT_TRUE (node->local_work_generation_enabled ()); nano::block_hash hash{ 1 }; - boost::optional work; + std::optional work; std::atomic done{ false }; - auto callback = [&work, &done] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&work, &done] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); work = work_a; done = true; }; @@ -233,10 +233,10 @@ TEST (distributed_work, fail_resolve) nano::test::system system (1); auto node (system.nodes[0]); nano::block_hash hash{ 1 }; - boost::optional work; + std::optional work; std::atomic done{ false }; - auto callback = [&work, &done] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); + auto callback = [&work, &done] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); work = work_a; done = true; }; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index c4b600f0e6..493e8c52ad 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -48,19 +48,19 @@ TEST (node, work_generate) { auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base); auto work = node.work_generate_blocking (version, root, difficulty); - ASSERT_TRUE (work.is_initialized ()); - ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); + ASSERT_TRUE (work.has_value ()); + ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, work.value ()), difficulty); } { auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base); - boost::optional work; + std::optional work; do { work = node.work_generate_blocking (version, root, difficulty); - } while (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); - ASSERT_TRUE (work.is_initialized ()); - ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); - ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); + } while (nano::dev::network_params.work.difficulty (version, root, work.value ()) >= node.network_params.work.base); + ASSERT_TRUE (work.has_value ()); + ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, work.value ()), difficulty); + ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, work.value ()) >= node.network_params.work.base); } } diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 0735b5e4d6..0d147dba4f 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -796,7 +796,7 @@ TEST (websocket, work) // Generate work nano::block_hash hash{ 1 }; auto work (node1->work_generate_blocking (hash)); - ASSERT_TRUE (work.is_initialized ()); + ASSERT_TRUE (work.has_value ()); // Wait for the work notification ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready); @@ -827,7 +827,7 @@ TEST (websocket, work) nano::from_string_hex (result.get ("difficulty"), result_difficulty); ASSERT_GE (result_difficulty, node1->default_difficulty (nano::work_version::work_1)); ASSERT_NEAR (result.get ("multiplier"), nano::difficulty::to_multiplier (result_difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6); - ASSERT_EQ (result.get ("work"), nano::to_string_hex (work.get ())); + ASSERT_EQ (result.get ("work"), nano::to_string_hex (work.value ())); ASSERT_EQ (1, contents.count ("bad_peers")); auto & bad_peers = contents.get_child ("bad_peers"); diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index 7d1849fb9b..3f2ffcb2d7 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -68,7 +68,7 @@ void nano::distributed_work::start () else if (need_resolve.empty () && request.callback) { status = work_generation_status::failure_local; - request.callback (boost::none); + request.callback (std::nullopt); } for (auto const & peer : need_resolve) { @@ -117,7 +117,7 @@ void nano::distributed_work::start_local () this_l->status = work_generation_status::failure_local; if (this_l->request.callback) { - this_l->request.callback (boost::none); + this_l->request.callback (std::nullopt); } } this_l->stop_once (false); @@ -143,9 +143,9 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) rpc_request.put ("action", "work_generate"); rpc_request.put ("hash", this_l->request.root.to_string ()); rpc_request.put ("difficulty", nano::to_string_hex (this_l->request.difficulty)); - if (this_l->request.account.is_initialized ()) + if (this_l->request.account.has_value ()) { - rpc_request.put ("account", this_l->request.account.get ().to_account ()); + rpc_request.put ("account", this_l->request.account.value ().to_account ()); } std::stringstream ostream; boost::property_tree::write_json (ostream, rpc_request); @@ -373,7 +373,7 @@ void nano::distributed_work::cancel () status = work_generation_status::cancelled; if (request.callback) { - request.callback (boost::none); + request.callback (std::nullopt); } stop_once (true); } @@ -411,7 +411,7 @@ void nano::distributed_work::handle_failure () } if (error_l && request_l.callback) { - request_l.callback (boost::none); + request_l.callback (std::nullopt); } }); } diff --git a/nano/node/distributed_work.hpp b/nano/node/distributed_work.hpp index e8772b3c63..17edecc60b 100644 --- a/nano/node/distributed_work.hpp +++ b/nano/node/distributed_work.hpp @@ -9,6 +9,8 @@ #include #include +#include + using request_type = boost::beast::http::request; namespace boost @@ -28,8 +30,8 @@ struct work_request final nano::work_version version; nano::root root; uint64_t difficulty; - boost::optional const account; - std::function)> callback; + std::optional const account; + std::function)> callback; std::vector> const peers; }; @@ -107,4 +109,4 @@ class distributed_work final : public std::enable_shared_from_this stopped{ false }; std::atomic local_generation_started{ false }; }; -} \ No newline at end of file +} diff --git a/nano/node/distributed_work_factory.cpp b/nano/node/distributed_work_factory.cpp index 2fd41aaf5a..a0c1ac64cc 100644 --- a/nano/node/distributed_work_factory.cpp +++ b/nano/node/distributed_work_factory.cpp @@ -12,7 +12,7 @@ nano::distributed_work_factory::~distributed_work_factory () stop (); } -bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector> const & peers_a, uint64_t difficulty_a, std::function)> const & callback_a, boost::optional const & account_a) +bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector> const & peers_a, uint64_t difficulty_a, std::function)> const & callback_a, std::optional const & account_a) { return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a }); } diff --git a/nano/node/distributed_work_factory.hpp b/nano/node/distributed_work_factory.hpp index ae626ead0e..97c697aa9e 100644 --- a/nano/node/distributed_work_factory.hpp +++ b/nano/node/distributed_work_factory.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -20,7 +21,7 @@ class distributed_work_factory final public: distributed_work_factory (nano::node &); ~distributed_work_factory (); - bool make (nano::work_version const, nano::root const &, std::vector> const &, uint64_t, std::function)> const &, boost::optional const & = boost::none); + bool make (nano::work_version const, nano::root const &, std::vector> const &, uint64_t, std::function)> const &, std::optional const & = std::nullopt); bool make (std::chrono::seconds const &, nano::work_request const &); void cancel (nano::root const &); void cleanup_finished (); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 2639aa44b5..eb2db379a2 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1613,10 +1613,10 @@ void nano::json_handler::block_create () // Wrapper from argument to lambda capture, to extend the block's scope auto get_callback_l = [rpc_l, block_response_put_l] (std::shared_ptr const & block_a) { // Callback upon work generation success or failure - return [block_a, rpc_l, block_response_put_l] (boost::optional const & work_a) { + return [block_a, rpc_l, block_response_put_l] (std::optional const & work_a) { if (block_a != nullptr) { - if (work_a.is_initialized ()) + if (work_a.has_value ()) { block_a->block_work_set (*work_a); block_response_put_l (*block_a); @@ -4994,7 +4994,7 @@ void nano::json_handler::wallet_work_get () void nano::json_handler::work_generate () { - boost::optional account; + std::optional account; auto account_opt (request.get_optional ("account")); // Default to work_1 if not specified auto work_version (work_version_optional_impl (nano::work_version::work_1)); @@ -5046,7 +5046,7 @@ void nano::json_handler::work_generate () { auto use_peers (request.get ("use_peers", false)); auto rpc_l (shared_from_this ()); - auto callback = [rpc_l, hash, work_version, this] (boost::optional const & work_a) { + auto callback = [rpc_l, hash, work_version, this] (std::optional const & work_a) { if (work_a) { boost::property_tree::ptree response_l; diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 09d119f262..0af8e6da70 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1078,50 +1078,50 @@ bool nano::node::work_generation_enabled (std::vector nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) +std::optional nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) { auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account ())); - if (opt_work_l.is_initialized ()) + if (opt_work_l.has_value ()) { - block_a.block_work_set (*opt_work_l); + block_a.block_work_set (opt_work_l.value ()); } return opt_work_l; } -void nano::node::work_generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function)> callback_a, boost::optional const & account_a, bool secondary_work_peers_a) +void nano::node::work_generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function)> callback_a, std::optional const & account_a, bool secondary_work_peers_a) { auto const & peers_l (secondary_work_peers_a ? config.secondary_work_peers : config.work_peers); if (distributed_work.make (version_a, root_a, peers_l, difficulty_a, callback_a, account_a)) { // Error in creating the job (either stopped or work generation is not possible) - callback_a (boost::none); + callback_a (std::nullopt); } } -boost::optional nano::node::work_generate_blocking (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, boost::optional const & account_a) +std::optional nano::node::work_generate_blocking (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::optional const & account_a) { - std::promise> promise; + std::promise> promise; work_generate ( - version_a, root_a, difficulty_a, [&promise] (boost::optional opt_work_a) { + version_a, root_a, difficulty_a, [&promise] (std::optional opt_work_a) { promise.set_value (opt_work_a); }, account_a); return promise.get_future ().get (); } -boost::optional nano::node::work_generate_blocking (nano::block & block_a) +std::optional nano::node::work_generate_blocking (nano::block & block_a) { debug_assert (network_params.network.is_dev_network ()); return work_generate_blocking (block_a, default_difficulty (nano::work_version::work_1)); } -boost::optional nano::node::work_generate_blocking (nano::root const & root_a) +std::optional nano::node::work_generate_blocking (nano::root const & root_a) { debug_assert (network_params.network.is_dev_network ()); return work_generate_blocking (root_a, default_difficulty (nano::work_version::work_1)); } -boost::optional nano::node::work_generate_blocking (nano::root const & root_a, uint64_t difficulty_a) +std::optional nano::node::work_generate_blocking (nano::root const & root_a, uint64_t difficulty_a) { debug_assert (network_params.network.is_dev_network ()); return work_generate_blocking (nano::work_version::work_1, root_a, difficulty_a); diff --git a/nano/node/node.hpp b/nano/node/node.hpp index d4105e61e4..205436a60f 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -43,6 +43,7 @@ #include #include +#include #include namespace nano @@ -111,9 +112,9 @@ class node final : public std::enable_shared_from_this bool local_work_generation_enabled () const; bool work_generation_enabled () const; bool work_generation_enabled (std::vector> const &) const; - boost::optional work_generate_blocking (nano::block &, uint64_t); - boost::optional work_generate_blocking (nano::work_version const, nano::root const &, uint64_t, boost::optional const & = boost::none); - void work_generate (nano::work_version const, nano::root const &, uint64_t, std::function)>, boost::optional const & = boost::none, bool const = false); + std::optional work_generate_blocking (nano::block &, uint64_t); + std::optional work_generate_blocking (nano::work_version const, nano::root const &, uint64_t, std::optional const & = std::nullopt); + void work_generate (nano::work_version const, nano::root const &, uint64_t, std::function)>, std::optional const & = std::nullopt, bool const = false); void add_initial_peers (); void start_election (std::shared_ptr const & block); bool block_confirmed (nano::block_hash const &); @@ -199,11 +200,11 @@ class node final : public std::enable_shared_from_this // For tests only unsigned node_seq; // For tests only - boost::optional work_generate_blocking (nano::block &); + std::optional work_generate_blocking (nano::block &); // For tests only - boost::optional work_generate_blocking (nano::root const &, uint64_t); + std::optional work_generate_blocking (nano::root const &, uint64_t); // For tests only - boost::optional work_generate_blocking (nano::root const &); + std::optional work_generate_blocking (nano::root const &); public: // Testing convenience functions /** diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 53380f4b39..fde737b85d 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1050,7 +1050,7 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a account_a.to_account ()); debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ())); - error = !wallets.node.work_generate_blocking (*block_a, required_difficulty).is_initialized (); + error = !wallets.node.work_generate_blocking (*block_a, required_difficulty).has_value (); } if (!error) { @@ -1298,12 +1298,12 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::r { auto difficulty (wallets.node.default_difficulty (nano::work_version::work_1)); auto opt_work_l (wallets.node.work_generate_blocking (nano::work_version::work_1, root_a, difficulty, account_a)); - if (opt_work_l.is_initialized ()) + if (opt_work_l.has_value ()) { auto transaction_l (wallets.tx_begin_write ()); if (live () && store.exists (transaction_l, account_a)) { - work_update (transaction_l, account_a, root_a, *opt_work_l); + work_update (transaction_l, account_a, root_a, opt_work_l.value ()); } } else if (!wallets.node.stopped) diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 22c4221cae..640080b557 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -2253,7 +2253,7 @@ void nano_qt::block_creation::create_send () details.is_send = true; details.epoch = info.epoch (); auto const required_difficulty{ wallet.node.network_params.work.threshold (send.work_version (), details) }; - if (wallet.node.work_generate_blocking (send, required_difficulty).is_initialized ()) + if (wallet.node.work_generate_blocking (send, required_difficulty).has_value ()) { std::string block_l; send.serialize_json (block_l); @@ -2337,7 +2337,7 @@ void nano_qt::block_creation::create_receive () details.is_receive = true; details.epoch = std::max (info.epoch (), pending.epoch); auto required_difficulty{ wallet.node.network_params.work.threshold (receive.work_version (), details) }; - if (wallet.node.work_generate_blocking (receive, required_difficulty).is_initialized ()) + if (wallet.node.work_generate_blocking (receive, required_difficulty).has_value ()) { std::string block_l; receive.serialize_json (block_l); @@ -2420,7 +2420,7 @@ void nano_qt::block_creation::create_change () nano::block_details details; details.epoch = info.epoch (); auto const required_difficulty{ wallet.node.network_params.work.threshold (change.work_version (), details) }; - if (wallet.node.work_generate_blocking (change, required_difficulty).is_initialized ()) + if (wallet.node.work_generate_blocking (change, required_difficulty).has_value ()) { std::string block_l; change.serialize_json (block_l); @@ -2502,7 +2502,7 @@ void nano_qt::block_creation::create_open () details.is_receive = true; details.epoch = pending.epoch; auto const required_difficulty{ wallet.node.network_params.work.threshold (open.work_version (), details) }; - if (wallet.node.work_generate_blocking (open, required_difficulty).is_initialized ()) + if (wallet.node.work_generate_blocking (open, required_difficulty).has_value ()) { std::string block_l; open.serialize_json (block_l); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index bbd88b8fa6..16fd731465 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -2088,9 +2088,9 @@ TEST (rpc, work_peer_bad) auto const rpc_ctx = add_rpc (system, node1); nano::block_hash hash1 (1); std::atomic work (0); - node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); - work = *work_a; + node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); + work = work_a.value (); }); ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash1, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } @@ -2107,9 +2107,9 @@ TEST (rpc, DISABLED_work_peer_one) node2.config.work_peers.emplace_back (node1->network.endpoint ().address ().to_string (), rpc_ctx.rpc->listening_port ()); nano::keypair key1; std::atomic work (0); - node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (boost::optional work_a) { - ASSERT_TRUE (work_a.is_initialized ()); - work = *work_a; + node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (std::optional work_a) { + ASSERT_TRUE (work_a.has_value ()); + work = work_a.value (); }); ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } @@ -2138,7 +2138,7 @@ TEST (rpc, DISABLED_work_peer_many) for (auto & work : works) { nano::keypair key1; - node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work] (boost::optional work_a) { + node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work] (std::optional work_a) { work = *work_a; }); while (nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, work) < nano::dev::network_params.work.threshold_base (nano::work_version::work_1)) From 122a935306d33f1fc6031ec65e37b6cdb41cbd54 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 15:58:23 +0000 Subject: [PATCH 155/190] Change block::account to return an std::optional if the block actually contains the field. Fixes up call sites that checked against the old sentinel value 0. Convert many call sites to using ledger::account(block&) when possible. --- nano/core_test/active_transactions.cpp | 4 ++-- nano/core_test/backlog.cpp | 4 +--- nano/core_test/ledger.cpp | 2 +- nano/lib/blocks.cpp | 9 ++++----- nano/lib/blocks.hpp | 9 ++++++--- nano/node/active_transactions.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/cli.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 6 +----- nano/node/confirmation_height_unbounded.cpp | 6 +----- nano/node/ipc/flatbuffers_util.cpp | 4 ++-- nano/node/json_handler.cpp | 10 +++++----- nano/node/node.cpp | 6 +----- nano/node/nodeconfig.cpp | 4 ++-- nano/node/process_live_dispatcher.cpp | 3 +-- nano/node/request_aggregator.cpp | 4 ++-- nano/qt/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 4 ++-- nano/secure/common.cpp | 10 +++++----- nano/secure/ledger.cpp | 12 +++--------- nano/store/component.cpp | 8 ++++---- 23 files changed, 49 insertions(+), 68 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 2b1bc50d0e..85fc7a1eff 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1534,7 +1534,7 @@ TEST (active_transactions, allow_limited_overflow) // Insert the first part of the blocks into normal election scheduler for (auto const & block : blocks1) { - node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ()); + node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); } // Ensure number of active elections reaches AEC limit and there is no overfill @@ -1596,7 +1596,7 @@ TEST (active_transactions, allow_limited_overflow_adapt) // Insert the first part of the blocks into normal election scheduler for (auto const & block : blocks1) { - node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ()); + node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); } // Ensure number of active elections reaches AEC limit and there is no overfill diff --git a/nano/core_test/backlog.cpp b/nano/core_test/backlog.cpp index fa58f702c6..70ccb6b28c 100644 --- a/nano/core_test/backlog.cpp +++ b/nano/core_test/backlog.cpp @@ -33,9 +33,7 @@ TEST (backlog, population) auto all_activated = [&] () { nano::lock_guard lock{ mutex }; return std::all_of (blocks.begin (), blocks.end (), [&] (auto const & item) { - auto account = item->account (); - debug_assert (!account.is_zero ()); - return activated.count (account) != 0; + return activated.count (item->account ().value ()) != 0; }); }; ASSERT_TIMELY (5s, all_activated ()); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 9b776a165a..2e6115132e 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -4052,7 +4052,7 @@ TEST (ledger, epoch_open_pending) ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); ASSERT_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ())); // Open block should be inserted into unchecked - auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account ()).hash); + auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account ().value ()).hash); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ()); // New block to process epoch open diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 688e614d13..253ecaa7e4 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -185,10 +185,9 @@ nano::link const & nano::block::link () const return link; } -nano::account const & nano::block::account () const +std::optional nano::block::account () const { - static nano::account account{}; - return account; + return std::nullopt; } nano::qualified_root nano::block::qualified_root () const @@ -643,7 +642,7 @@ nano::block_hash const & nano::open_block::previous () const return result; } -nano::account const & nano::open_block::account () const +std::optional nano::open_block::account () const { return hashables.account; } @@ -1213,7 +1212,7 @@ nano::block_hash const & nano::state_block::previous () const return hashables.previous; } -nano::account const & nano::state_block::account () const +std::optional nano::state_block::account () const { return hashables.account; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index e89f2dddba..18514a9072 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -33,7 +33,6 @@ class block virtual void hash (blake2b_state &) const = 0; virtual uint64_t block_work () const = 0; virtual void block_work_set (uint64_t) = 0; - virtual nano::account const & account () const; // Previous block in account's chain, zero for open block virtual nano::block_hash const & previous () const = 0; // Source block for open/receive blocks, zero otherwise. @@ -64,6 +63,10 @@ class block // If there are any changes to the hashables, call this to update the cached hash void refresh (); +public: // Direct access to the block fields or nullopt if the block type does not have the specified field + // Account field for open/state blocks + virtual std::optional account () const; + protected: mutable nano::block_hash cached_hash{ 0 }; /** @@ -210,7 +213,7 @@ class open_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - nano::account const & account () const override; + std::optional account () const override; nano::block_hash const & source () const override; nano::root const & root () const override; nano::account const & representative () const override; @@ -325,7 +328,7 @@ class state_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - nano::account const & account () const override; + std::optional account () const override; nano::root const & root () const override; nano::link const & link () const override; nano::account const & representative () const override; diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 2545c5d41d..b5c4a83df4 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -186,7 +186,7 @@ void nano::active_transactions::notify_observers (nano::election_status const & void nano::active_transactions::handle_final_votes_confirmation (std::shared_ptr const & block, nano::store::read_transaction const & transaction, nano::election_status_type status) { - auto const & account = !block->account ().is_zero () ? block->account () : block->sideband ().account; + auto account = node.ledger.account (*block); bool is_canary_not_set = !node.ledger.cache.final_votes_confirmation_canary.load (); bool is_canary_account = account == node.network_params.ledger.final_votes_canary_account; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 731a000f76..54297c733c 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -362,7 +362,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } case nano::block_status::gap_epoch_open_pending: { - node.unchecked.put (block->account (), block); // Specific unchecked key starting with epoch open block account public key + node.unchecked.put (block->account ().value_or (0), block); // Specific unchecked key starting with epoch open block account public key node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index cad42863be..00e9a8ecee 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -188,7 +188,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: } if (pull_blocks == 0 && block_expected) { - known_account = block->account (); + known_account = block->account ().value_or (0); } if (connection->block_count++ == 0) { diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 2db59429df..aad14eb008 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -167,7 +167,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, break; case nano::block_status::gap_source: { - const auto account = block.previous ().is_zero () ? block.account () : ledger.account (tx, block.previous ()).value (); + const auto account = block.previous ().is_zero () ? block.account ().value () : ledger.account (tx, block.previous ()).value (); const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); // Mark account as blocked because it is missing the source block diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 984f1656f4..2f3372e40b 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1324,7 +1324,7 @@ void reset_confirmation_heights (nano::store::write_transaction const & transact store.confirmation_height.clear (transaction); // Then make sure the confirmation height of the genesis account open block is 1 - store.confirmation_height.put (transaction, constants.genesis->account (), { 1, constants.genesis->hash () }); + store.confirmation_height.put (transaction, constants.genesis->account ().value (), { 1, constants.genesis->hash () }); } bool is_using_rocksdb (std::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec) diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 53c3ffbf30..4d221a3f5a 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -104,11 +104,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or release_assert (block); } } - nano::account account (block->account ()); - if (account.is_zero ()) - { - account = block->sideband ().account; - } + auto account = ledger.account (*block); // Checks if we have encountered this account before but not commited changes yet, if so then update the cached confirmation height nano::confirmation_height_info confirmation_height_info; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 03c4c42a24..cae1ec5cf0 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -79,11 +79,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr } release_assert (block); - nano::account account (block->account ()); - if (account.is_zero ()) - { - account = block->sideband ().account; - } + auto account = ledger.account (*block); auto block_height = block->sideband ().height; uint64_t confirmation_height = 0; diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 8cf1fe5e40..eb90c47311 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -6,7 +6,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { auto block (std::make_unique ()); - block->account = block_a.account ().to_account (); + block->account = block_a.account ().value ().to_account (); block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); @@ -63,7 +63,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); block->source = block_a.source ().to_string (); - block->account = block_a.account ().to_account (); + block->account = block_a.account ().value ().to_account (); block->representative = block_a.representative ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index eb2db379a2..f6afe32f7e 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -415,7 +415,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) if (!link.is_zero () && !details.is_send) { auto block_link = node.ledger.block (transaction, link.as_block_hash ()); - if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ()))) + if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account ().value (), link.as_block_hash ()))) { details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); details.is_receive = true; @@ -1131,7 +1131,7 @@ void nano::json_handler::active_difficulty () void nano::json_handler::available_supply () { - auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ())); // Cold storage genesis + auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ().value ())); // Cold storage genesis auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account auto burned_balance ((node.balance_pending (nano::account{}, false)).second); // Burning 0 account @@ -1149,7 +1149,7 @@ void nano::json_handler::block_info () auto block = node.ledger.block (transaction, hash); if (block != nullptr) { - nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); + auto account = node.ledger.account (*block); response_l.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); if (amount) @@ -1306,7 +1306,7 @@ void nano::json_handler::blocks_info () if (block != nullptr) { boost::property_tree::ptree entry; - nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); + auto account = node.ledger.account (*block); entry.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); if (amount) @@ -2454,7 +2454,7 @@ class history_visitor : public nano::block_visitor } else { - tree.put ("account", handler.node.ledger.constants.genesis->account ().to_account ()); + tree.put ("account", handler.node.ledger.constants.genesis->account ().value ().to_account ()); tree.put ("amount", nano::dev::constants.genesis_amount.convert_to ()); } } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 0af8e6da70..bcf845bf96 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1226,11 +1226,7 @@ void nano::node::receive_confirmed (store::transaction const & block_transaction void nano::node::process_confirmed_data (store::transaction const & transaction_a, std::shared_ptr const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, bool & is_state_epoch_a, nano::account & pending_account_a) { // Faster account calculation - account_a = block_a->account (); - if (account_a.is_zero ()) - { - account_a = block_a->sideband ().account; - } + account_a = ledger.account (*block_a); // Faster amount calculation auto previous (block_a->previous ()); auto previous_balance = ledger.balance (transaction_a, previous); diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index beb93cb4f4..edd039d820 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -49,7 +49,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, { case nano::networks::nano_dev_network: enable_voting = true; - preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); break; case nano::networks::nano_beta_network: { @@ -72,7 +72,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, break; case nano::networks::nano_test_network: preconfigured_peers.push_back (default_test_peer_network); - preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); break; default: debug_assert (false); diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index 8411851d42..4fd77e3c37 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -45,8 +45,7 @@ void nano::process_live_dispatcher::process_live (nano::block const & block, sto // Start collecting quorum on block if (ledger.dependents_confirmed (transaction, block)) { - auto account = block.account ().is_zero () ? block.sideband ().account : block.account (); - scheduler.activate (account, transaction); + scheduler.activate (ledger.account (block), transaction); } if (websocket.server && websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index f822ace915..43e417219c 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -229,7 +229,7 @@ std::pair>, std::vectoraccount ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); + ledger.store.confirmation_height.get (transaction, ledger.account (*block), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } @@ -265,7 +265,7 @@ std::pair>, std::vectoraccount ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); + ledger.store.confirmation_height.get (transaction, ledger.account (*block), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 640080b557..4942294f30 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -566,7 +566,7 @@ class short_text_visitor : public nano::block_visitor } else { - account = ledger.constants.genesis->account (); + account = ledger.constants.genesis->account ().value (); amount = nano::dev::constants.genesis_amount; } } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 16fd731465..9045fc4132 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -3314,7 +3314,7 @@ TEST (rpc, pending_exists) ASSERT_TRUE (pending_exists ("1")); ASSERT_TRUE (pending_exists ("1")); - reset_confirmation_height (node->store, block1->account ()); + reset_confirmation_height (node->store, block1->account ().value ()); ASSERT_TRUE (pending_exists ("0")); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (pending_exists ("1")); @@ -3419,7 +3419,7 @@ TEST (rpc, wallet_receivable) ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); - reset_confirmation_height (system.nodes.front ()->store, block1->account ()); + reset_confirmation_height (system.nodes.front ()->store, block1->account ().value ()); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 091e45fcc4..0812ee4ea8 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -127,15 +127,15 @@ nano::ledger_constants::ledger_constants (nano::work_thresholds & work, nano::ne : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height : nano_live_final_votes_canary_height) { - nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano::link epoch_link_v1; char const * epoch_message_v1 ("epoch v1 block"); strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ()); - epochs.add (nano::epoch::epoch_1, genesis->account (), epoch_link_v1); + epochs.add (nano::epoch::epoch_1, genesis->account ().value (), epoch_link_v1); nano::link epoch_link_v2; nano::account nano_live_epoch_v2_signer; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 561a87c074..be4afa8d2d 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1132,13 +1132,7 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan nano::account nano::ledger::account (nano::block const & block) { debug_assert (block.has_sideband ()); - nano::account result (block.account ()); - if (result.is_zero ()) - { - result = block.sideband ().account; - } - debug_assert (!result.is_zero ()); - return result; + return block.account ().value_or (block.sideband ().account); } std::optional nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const @@ -1431,7 +1425,7 @@ bool nano::ledger::block_confirmed (store::transaction const & transaction_a, na if (block_l) { nano::confirmation_height_info confirmation_height_info; - store.confirmation_height.get (transaction_a, block_l->account ().is_zero () ? block_l->sideband ().account : block_l->account (), confirmation_height_info); + store.confirmation_height.get (transaction_a, account (*block_l), confirmation_height_info); auto confirmed (confirmation_height_info.height >= block_l->sideband ().height); return confirmed; } @@ -1616,7 +1610,7 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (std::filesystem::path const & data_p auto random_block (store.block.random (lmdb_transaction)); error |= rocksdb_store->block.get (rocksdb_transaction, random_block->hash ()) == nullptr; - auto account = random_block->account ().is_zero () ? random_block->sideband ().account : random_block->account (); + auto account = this->account (*random_block); nano::account_info account_info; error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info); diff --git a/nano/store/component.cpp b/nano/store/component.cpp index 67826f6345..c95c16a19e 100644 --- a/nano/store/component.cpp +++ b/nano/store/component.cpp @@ -31,11 +31,11 @@ void nano::store::component::initialize (store::write_transaction const & transa auto hash_l (constants.genesis->hash ()); block.put (transaction_a, hash_l, *constants.genesis); ++ledger_cache_a.block_count; - confirmation_height.put (transaction_a, constants.genesis->account (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); + confirmation_height.put (transaction_a, constants.genesis->account ().value (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); ++ledger_cache_a.cemented_count; ledger_cache_a.final_votes_confirmation_canary = (constants.final_votes_canary_account == constants.genesis->account () && 1 >= constants.final_votes_canary_height); - account.put (transaction_a, constants.genesis->account (), { hash_l, constants.genesis->account (), constants.genesis->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); + account.put (transaction_a, constants.genesis->account ().value (), { hash_l, constants.genesis->account ().value (), constants.genesis->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); ++ledger_cache_a.account_count; - ledger_cache_a.rep_weights.representation_put (constants.genesis->account (), std::numeric_limits::max ()); - frontier.put (transaction_a, hash_l, constants.genesis->account ()); + ledger_cache_a.rep_weights.representation_put (constants.genesis->account ().value (), std::numeric_limits::max ()); + frontier.put (transaction_a, hash_l, constants.genesis->account ().value ()); } From 49a6b4119be34b6f9fa4e2922522650173d35840 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 8 Mar 2024 15:52:09 +0000 Subject: [PATCH 156/190] Fix comment of rep_crawler::process function --- nano/node/repcrawler.hpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index e850b8f68a..0855a7bdee 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -57,10 +57,8 @@ class rep_crawler final void stop (); /** - * Called when a non-replay vote on a block previously sent by query() is received. This indicates - * with high probability that the endpoint is a representative node. - * The force flag can be set to skip the active check in unit testing when we want to force a vote in the rep crawler. - * @return false if any vote passed the checks and was added to the response queue of the rep crawler + * Called when a non-replay vote arrives that might be of interest to rep crawler. + * @return true, if the vote was of interest and was processed, this indicates that the rep is likely online and voting */ bool process (std::shared_ptr const &, std::shared_ptr const &); From a7cab75095c8c77c06f43d9a4646b6dd09e703cb Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 17:14:00 +0000 Subject: [PATCH 157/190] ledger::account is moved to block::account and block::account which accesses the account field is renamed to block::account_field. --- nano/core_test/active_transactions.cpp | 4 ++-- nano/core_test/backlog.cpp | 2 +- nano/core_test/ledger.cpp | 12 +++++------ nano/lib/blocks.cpp | 23 ++++++++++++++++++--- nano/lib/blocks.hpp | 12 ++++++++--- nano/node/active_transactions.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 4 ++-- nano/node/bootstrap_ascending/service.cpp | 6 +++--- nano/node/cli.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 4 ++-- nano/node/json_handler.cpp | 18 ++++++++-------- nano/node/node.cpp | 4 ++-- nano/node/nodeconfig.cpp | 4 ++-- nano/node/process_live_dispatcher.cpp | 2 +- nano/node/request_aggregator.cpp | 4 ++-- nano/qt/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 4 ++-- nano/secure/common.cpp | 10 ++++----- nano/secure/ledger.cpp | 18 ++++++---------- nano/secure/ledger.hpp | 4 ---- nano/store/component.cpp | 8 +++---- 24 files changed, 84 insertions(+), 71 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 85fc7a1eff..2b1bc50d0e 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1534,7 +1534,7 @@ TEST (active_transactions, allow_limited_overflow) // Insert the first part of the blocks into normal election scheduler for (auto const & block : blocks1) { - node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); + node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ()); } // Ensure number of active elections reaches AEC limit and there is no overfill @@ -1596,7 +1596,7 @@ TEST (active_transactions, allow_limited_overflow_adapt) // Insert the first part of the blocks into normal election scheduler for (auto const & block : blocks1) { - node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); + node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ()); } // Ensure number of active elections reaches AEC limit and there is no overfill diff --git a/nano/core_test/backlog.cpp b/nano/core_test/backlog.cpp index 70ccb6b28c..26d5680a88 100644 --- a/nano/core_test/backlog.cpp +++ b/nano/core_test/backlog.cpp @@ -33,7 +33,7 @@ TEST (backlog, population) auto all_activated = [&] () { nano::lock_guard lock{ mutex }; return std::all_of (blocks.begin (), blocks.end (), [&] (auto const & item) { - return activated.count (item->account ().value ()) != 0; + return activated.count (item->account ()) != 0; }); }; ASSERT_TIMELY (5s, all_activated ()); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 2e6115132e..be50f1eec0 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -113,7 +113,7 @@ TEST (ledger, process_send) ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, hash1)); ASSERT_EQ (nano::block_status::progress, return1); - ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*send)); + ASSERT_EQ (nano::dev::genesis_key.pub, send->account ()); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_receivable (transaction, key2.pub)); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); @@ -142,7 +142,7 @@ TEST (ledger, process_send) ASSERT_EQ (1, open->sideband ().height); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (nano::block_status::progress, return2); - ASSERT_EQ (key2.pub, ledger.account (*open)); + ASSERT_EQ (key2.pub, open->account ()); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -226,7 +226,7 @@ TEST (ledger, process_receive) nano::block_hash hash2 (open->hash ()); auto return1 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return1); - ASSERT_EQ (key2.pub, ledger.account (*open)); + ASSERT_EQ (key2.pub, open->account ()); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (1, open->sideband ().height); @@ -259,7 +259,7 @@ TEST (ledger, process_receive) ASSERT_TRUE (store.frontier.get (transaction, hash2).is_zero ()); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash4)); ASSERT_EQ (nano::block_status::progress, return2); - ASSERT_EQ (key2.pub, ledger.account (*receive)); + ASSERT_EQ (key2.pub, receive->account ()); ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.account_receivable (transaction, key2.pub)); @@ -526,7 +526,7 @@ TEST (ledger, representative_change) ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); ASSERT_EQ (nano::block_status::progress, return1); - ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*block)); + ASSERT_EQ (nano::dev::genesis_key.pub, block->account ()); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key2.pub)); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); @@ -4052,7 +4052,7 @@ TEST (ledger, epoch_open_pending) ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); ASSERT_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ())); // Open block should be inserted into unchecked - auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account ().value ()).hash); + auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account_field ().value ()).hash); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ()); // New block to process epoch open diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 253ecaa7e4..c2f5cbc2f5 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -185,7 +185,24 @@ nano::link const & nano::block::link () const return link; } -std::optional nano::block::account () const +nano::account nano::block::account () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case block_type::open: + case block_type::state: + return account_field ().value (); + case block_type::change: + case block_type::send: + case block_type::receive: + return sideband ().account; + default: + release_assert (false); + } +} + +std::optional nano::block::account_field () const { return std::nullopt; } @@ -642,7 +659,7 @@ nano::block_hash const & nano::open_block::previous () const return result; } -std::optional nano::open_block::account () const +std::optional nano::open_block::account_field () const { return hashables.account; } @@ -1212,7 +1229,7 @@ nano::block_hash const & nano::state_block::previous () const return hashables.previous; } -std::optional nano::state_block::account () const +std::optional nano::state_block::account_field () const { return hashables.account; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 18514a9072..f4a47650ef 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -64,8 +64,10 @@ class block void refresh (); public: // Direct access to the block fields or nullopt if the block type does not have the specified field + // Returns account field or account from sideband + nano::account account () const noexcept; // Account field for open/state blocks - virtual std::optional account () const; + virtual std::optional account_field () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -213,7 +215,6 @@ class open_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - std::optional account () const override; nano::block_hash const & source () const override; nano::root const & root () const override; nano::account const & representative () const override; @@ -235,6 +236,9 @@ class open_block : public nano::block uint64_t work; static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); +public: // Open block fields + std::optional account_field () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; @@ -328,7 +332,6 @@ class state_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - std::optional account () const override; nano::root const & root () const override; nano::link const & link () const override; nano::account const & representative () const override; @@ -351,6 +354,9 @@ class state_block : public nano::block uint64_t work; static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); +public: // State block fields + std::optional account_field () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index b5c4a83df4..0b39a6c678 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -186,7 +186,7 @@ void nano::active_transactions::notify_observers (nano::election_status const & void nano::active_transactions::handle_final_votes_confirmation (std::shared_ptr const & block, nano::store::read_transaction const & transaction, nano::election_status_type status) { - auto account = node.ledger.account (*block); + auto account = block->account (); bool is_canary_not_set = !node.ledger.cache.final_votes_confirmation_canary.load (); bool is_canary_account = account == node.network_params.ledger.final_votes_canary_account; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 54297c733c..ecbd669855 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -362,7 +362,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } case nano::block_status::gap_epoch_open_pending: { - node.unchecked.put (block->account ().value_or (0), block); // Specific unchecked key starting with epoch open block account public key + node.unchecked.put (block->account_field ().value_or (0), block); // Specific unchecked key starting with epoch open block account public key node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 00e9a8ecee..d4b4e13215 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -176,7 +176,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: // Is block expected? bool block_expected (false); // Unconfirmed head is used only for lazy destinations if legacy bootstrap is not available, see nano::bootstrap_attempt::lazy_destinations_increment (...) - bool unconfirmed_account_head = node->flags.disable_legacy_bootstrap && pull_blocks == 0 && pull.retry_limit <= node->network_params.bootstrap.lazy_retry_limit && (expected == pull.account_or_head.as_block_hash ()) && (block->account () == pull.account_or_head.as_account ()); + bool unconfirmed_account_head = node->flags.disable_legacy_bootstrap && pull_blocks == 0 && pull.retry_limit <= node->network_params.bootstrap.lazy_retry_limit && (expected == pull.account_or_head.as_block_hash ()) && (block->account_field () == pull.account_or_head.as_account ()); if (hash == expected || unconfirmed_account_head) { expected = block->previous (); @@ -188,7 +188,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: } if (pull_blocks == 0 && block_expected) { - known_account = block->account ().value_or (0); + known_account = block->account_field ().value_or (0); } if (connection->block_count++ == 0) { diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index aad14eb008..33746a1d63 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -133,7 +133,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, { case nano::block_status::progress: { - const auto account = ledger.account (block); + const auto account = block.account (); const auto is_send = ledger.is_send (tx, block); // If we've inserted any block in to an account, unmark it as blocked @@ -167,7 +167,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, break; case nano::block_status::gap_source: { - const auto account = block.previous ().is_zero () ? block.account ().value () : ledger.account (tx, block.previous ()).value (); + const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value (); const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); // Mark account as blocked because it is missing the source block @@ -456,7 +456,7 @@ nano::bootstrap_ascending::service::verify_result nano::bootstrap_ascending::ser case async_tag::query_type::blocks_by_account: { // Open & state blocks always contain account field - if (first->account () != tag.start.as_account ()) + if (first->account_field () != tag.start.as_account ()) { // TODO: Stat & log return verify_result::invalid; diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 2f3372e40b..984f1656f4 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1324,7 +1324,7 @@ void reset_confirmation_heights (nano::store::write_transaction const & transact store.confirmation_height.clear (transaction); // Then make sure the confirmation height of the genesis account open block is 1 - store.confirmation_height.put (transaction, constants.genesis->account ().value (), { 1, constants.genesis->hash () }); + store.confirmation_height.put (transaction, constants.genesis->account (), { 1, constants.genesis->hash () }); } bool is_using_rocksdb (std::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec) diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 4d221a3f5a..68faaf07a8 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -104,7 +104,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or release_assert (block); } } - auto account = ledger.account (*block); + auto account = block->account (); // Checks if we have encountered this account before but not commited changes yet, if so then update the cached confirmation height nano::confirmation_height_info confirmation_height_info; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index cae1ec5cf0..b93fc63547 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -79,7 +79,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr } release_assert (block); - auto account = ledger.account (*block); + auto account = block->account (); auto block_height = block->sideband ().height; uint64_t confirmation_height = 0; diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index eb90c47311..8cf1fe5e40 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -6,7 +6,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { auto block (std::make_unique ()); - block->account = block_a.account ().value ().to_account (); + block->account = block_a.account ().to_account (); block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); @@ -63,7 +63,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); block->source = block_a.source ().to_string (); - block->account = block_a.account ().value ().to_account (); + block->account = block_a.account ().to_account (); block->representative = block_a.representative ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index f6afe32f7e..5b271232b0 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -415,7 +415,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) if (!link.is_zero () && !details.is_send) { auto block_link = node.ledger.block (transaction, link.as_block_hash ()); - if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account ().value (), link.as_block_hash ()))) + auto account = block_a.account_field ().value (); // Link is non-zero therefore it's a state block and has an account field; + if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (account, link.as_block_hash ()))) { details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); details.is_receive = true; @@ -1131,7 +1132,7 @@ void nano::json_handler::active_difficulty () void nano::json_handler::available_supply () { - auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ().value ())); // Cold storage genesis + auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ())); // Cold storage genesis auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account auto burned_balance ((node.balance_pending (nano::account{}, false)).second); // Burning 0 account @@ -1149,7 +1150,7 @@ void nano::json_handler::block_info () auto block = node.ledger.block (transaction, hash); if (block != nullptr) { - auto account = node.ledger.account (*block); + auto account = block->account (); response_l.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); if (amount) @@ -1214,7 +1215,7 @@ void nano::json_handler::block_confirm () nano::election_status status{ block_l, 0, 0, std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height }; node.active.recently_cemented.put (status); // Trigger callback for confirmed block - auto account = node.ledger.account (*block_l); + auto account = block_l->account (); auto amount = node.ledger.amount (transaction, hash); bool is_state_send (false); bool is_state_epoch (false); @@ -1306,7 +1307,7 @@ void nano::json_handler::blocks_info () if (block != nullptr) { boost::property_tree::ptree entry; - auto account = node.ledger.account (*block); + auto account = block->account (); entry.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); if (amount) @@ -1386,8 +1387,7 @@ void nano::json_handler::blocks_info () auto block_a = node.ledger.block (transaction, source_hash); if (block_a != nullptr) { - auto source_account (node.ledger.account (*block_a)); - entry.put ("source_account", source_account.to_account ()); + entry.put ("source_account", block_a->account ().to_account ()); } else { @@ -1433,7 +1433,7 @@ void nano::json_handler::block_account () auto block = node.ledger.block (transaction, hash); if (block) { - response_l.put ("account", node.ledger.account (*block).to_account ()); + response_l.put ("account", block->account ().to_account ()); } else { @@ -2454,7 +2454,7 @@ class history_visitor : public nano::block_visitor } else { - tree.put ("account", handler.node.ledger.constants.genesis->account ().value ().to_account ()); + tree.put ("account", handler.node.ledger.constants.genesis->account ().to_account ()); tree.put ("amount", nano::dev::constants.genesis_amount.convert_to ()); } } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index bcf845bf96..61a1c7fe19 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1080,7 +1080,7 @@ bool nano::node::work_generation_enabled (std::vector nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) { - auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account ())); + auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account_field ())); if (opt_work_l.has_value ()) { block_a.block_work_set (opt_work_l.value ()); @@ -1226,7 +1226,7 @@ void nano::node::receive_confirmed (store::transaction const & block_transaction void nano::node::process_confirmed_data (store::transaction const & transaction_a, std::shared_ptr const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, bool & is_state_epoch_a, nano::account & pending_account_a) { // Faster account calculation - account_a = ledger.account (*block_a); + account_a = block_a->account (); // Faster amount calculation auto previous (block_a->previous ()); auto previous_balance = ledger.balance (transaction_a, previous); diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index edd039d820..beb93cb4f4 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -49,7 +49,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, { case nano::networks::nano_dev_network: enable_voting = true; - preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); break; case nano::networks::nano_beta_network: { @@ -72,7 +72,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, break; case nano::networks::nano_test_network: preconfigured_peers.push_back (default_test_peer_network); - preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); break; default: debug_assert (false); diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index 4fd77e3c37..f0d457dbef 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -45,7 +45,7 @@ void nano::process_live_dispatcher::process_live (nano::block const & block, sto // Start collecting quorum on block if (ledger.dependents_confirmed (transaction, block)) { - scheduler.activate (ledger.account (block), transaction); + scheduler.activate (block.account (), transaction); } if (websocket.server && websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index 43e417219c..0e61195e87 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -229,7 +229,7 @@ std::pair>, std::vectoraccount (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } @@ -265,7 +265,7 @@ std::pair>, std::vectoraccount (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 4942294f30..640080b557 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -566,7 +566,7 @@ class short_text_visitor : public nano::block_visitor } else { - account = ledger.constants.genesis->account ().value (); + account = ledger.constants.genesis->account (); amount = nano::dev::constants.genesis_amount; } } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 9045fc4132..16fd731465 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -3314,7 +3314,7 @@ TEST (rpc, pending_exists) ASSERT_TRUE (pending_exists ("1")); ASSERT_TRUE (pending_exists ("1")); - reset_confirmation_height (node->store, block1->account ().value ()); + reset_confirmation_height (node->store, block1->account ()); ASSERT_TRUE (pending_exists ("0")); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (pending_exists ("1")); @@ -3419,7 +3419,7 @@ TEST (rpc, wallet_receivable) ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); - reset_confirmation_height (system.nodes.front ()->store, block1->account ().value ()); + reset_confirmation_height (system.nodes.front ()->store, block1->account ()); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 0812ee4ea8..6b91dd6766 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -127,15 +127,15 @@ nano::ledger_constants::ledger_constants (nano::work_thresholds & work, nano::ne : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height : nano_live_final_votes_canary_height) { - nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account_field ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account_field ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account_field ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account_field ().value (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano::link epoch_link_v1; char const * epoch_message_v1 ("epoch v1 block"); strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ()); - epochs.add (nano::epoch::epoch_1, genesis->account ().value (), epoch_link_v1); + epochs.add (nano::epoch::epoch_1, genesis->account (), epoch_link_v1); nano::link epoch_link_v2; nano::account nano_live_epoch_v2_signer; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index be4afa8d2d..7477722ed9 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -64,7 +64,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto amount = ledger.amount (transaction, hash).value (); - auto destination_account = ledger.account (block_a); + auto destination_account = block_a.account (); // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing auto source_account = ledger.account (transaction, block_a.hashables.source); auto info = ledger.account_info (transaction, destination_account); @@ -83,7 +83,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto amount = ledger.amount (transaction, hash).value (); - auto destination_account = ledger.account (block_a); + auto destination_account = block_a.account (); auto source_account = ledger.account (transaction, block_a.hashables.source); ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); nano::account_info new_info; @@ -97,7 +97,7 @@ class rollback_visitor : public nano::block_visitor { auto hash (block_a.hash ()); auto rep_block (ledger.representative (transaction, block_a.hashables.previous)); - auto account = ledger.account (block_a); + auto account = block_a.account (); auto info = ledger.account_info (transaction, account); debug_assert (info); auto balance = ledger.balance (transaction, block_a.hashables.previous).value (); @@ -1129,12 +1129,6 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan return rollback (transaction_a, block_a, rollback_list); } -nano::account nano::ledger::account (nano::block const & block) -{ - debug_assert (block.has_sideband ()); - return block.account ().value_or (block.sideband ().account); -} - std::optional nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const { auto block_l = block (transaction, hash); @@ -1142,7 +1136,7 @@ std::optional nano::ledger::account (store::transaction const & t { return std::nullopt; } - return account (*block_l); + return block_l->account (); } std::optional nano::ledger::account_info (store::transaction const & transaction, nano::account const & account) const @@ -1425,7 +1419,7 @@ bool nano::ledger::block_confirmed (store::transaction const & transaction_a, na if (block_l) { nano::confirmation_height_info confirmation_height_info; - store.confirmation_height.get (transaction_a, account (*block_l), confirmation_height_info); + store.confirmation_height.get (transaction_a, block_l->account (), confirmation_height_info); auto confirmed (confirmation_height_info.height >= block_l->sideband ().height); return confirmed; } @@ -1610,7 +1604,7 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (std::filesystem::path const & data_p auto random_block (store.block.random (lmdb_transaction)); error |= rocksdb_store->block.get (rocksdb_transaction, random_block->hash ()) == nullptr; - auto account = this->account (*random_block); + auto account = random_block->account (); nano::account_info account_info; error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 6b3eddd698..bfc1681dc6 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -30,10 +30,6 @@ class ledger final { public: ledger (nano::store::component &, nano::stats &, nano::ledger_constants & constants, nano::generate_cache const & = nano::generate_cache ()); - /** - * Return account containing hash, expects that block hash exists in ledger - */ - static nano::account account (nano::block const & block); /** * Returns the account for a given hash * Returns std::nullopt if the block doesn't exist or has been pruned diff --git a/nano/store/component.cpp b/nano/store/component.cpp index c95c16a19e..67826f6345 100644 --- a/nano/store/component.cpp +++ b/nano/store/component.cpp @@ -31,11 +31,11 @@ void nano::store::component::initialize (store::write_transaction const & transa auto hash_l (constants.genesis->hash ()); block.put (transaction_a, hash_l, *constants.genesis); ++ledger_cache_a.block_count; - confirmation_height.put (transaction_a, constants.genesis->account ().value (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); + confirmation_height.put (transaction_a, constants.genesis->account (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); ++ledger_cache_a.cemented_count; ledger_cache_a.final_votes_confirmation_canary = (constants.final_votes_canary_account == constants.genesis->account () && 1 >= constants.final_votes_canary_height); - account.put (transaction_a, constants.genesis->account ().value (), { hash_l, constants.genesis->account ().value (), constants.genesis->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); + account.put (transaction_a, constants.genesis->account (), { hash_l, constants.genesis->account (), constants.genesis->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); ++ledger_cache_a.account_count; - ledger_cache_a.rep_weights.representation_put (constants.genesis->account ().value (), std::numeric_limits::max ()); - frontier.put (transaction_a, hash_l, constants.genesis->account ().value ()); + ledger_cache_a.rep_weights.representation_put (constants.genesis->account (), std::numeric_limits::max ()); + frontier.put (transaction_a, hash_l, constants.genesis->account ()); } From deb5bf9017b2bcd2300c1e310f39bde12c031fc0 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 23:14:19 +0000 Subject: [PATCH 158/190] Change block::balance to return an std::optional if the block actually contains the field. --- nano/core_test/active_transactions.cpp | 4 ++-- nano/core_test/node.cpp | 32 +++++++++++++------------- nano/core_test/request_aggregator.cpp | 2 +- nano/lib/blocks.cpp | 9 ++++---- nano/lib/blocks.hpp | 9 +++++--- nano/node/bootstrap/bootstrap_lazy.cpp | 4 ++-- nano/node/ipc/flatbuffers_util.cpp | 4 ++-- nano/node/json_handler.cpp | 2 +- nano/secure/ledger.cpp | 4 ++-- 9 files changed, 36 insertions(+), 34 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 2b1bc50d0e..9f55c40180 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -502,14 +502,14 @@ TEST (active_transactions, inactive_votes_cache_election_start) auto send3 = send_block_builder.make_block () .previous (send2->hash ()) .destination (nano::keypair ().pub) - .balance (send2->balance ().number () - 1) + .balance (send2->balance ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); auto send4 = send_block_builder.make_block () .previous (send3->hash ()) .destination (nano::keypair ().pub) - .balance (send3->balance ().number () - 1) + .balance (send3->balance ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 493e8c52ad..0e065baf94 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3322,7 +3322,7 @@ TEST (node, rollback_vote_self) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().number () - 1) + .balance (send1->balance ().value ().number () - 1) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) @@ -3331,7 +3331,7 @@ TEST (node, rollback_vote_self) // fork of send2 block auto fork = builder.make_block () .from (*send2) - .balance (send1->balance ().number () - 2) + .balance (send1->balance ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); @@ -3419,7 +3419,7 @@ TEST (node, rollback_gap_source) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().number () - 1) + .balance (send1->balance ().value ().number () - 1) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) @@ -3510,7 +3510,7 @@ TEST (node, dependency_graph) .from (*gen_receive) .previous (gen_receive->hash ()) .link (key2.pub) - .balance (gen_receive->balance ().number () - 2) + .balance (gen_receive->balance ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); @@ -3549,7 +3549,7 @@ TEST (node, dependency_graph) .from (*key2_send1) .previous (key2_send1->hash ()) .link (key1.pub) - .balance (key2_send1->balance ().number () - 1) + .balance (key2_send1->balance ().value ().number () - 1) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2_send1->hash ())) .build (); @@ -3558,7 +3558,7 @@ TEST (node, dependency_graph) .from (*key1_send1) .previous (key1_send1->hash ()) .link (key2_send2->hash ()) - .balance (key1_send1->balance ().number () + 1) + .balance (key1_send1->balance ().value ().number () + 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_send1->hash ())) .build (); @@ -3567,7 +3567,7 @@ TEST (node, dependency_graph) .from (*key1_receive) .previous (key1_receive->hash ()) .link (key3.pub) - .balance (key1_receive->balance ().number () - 1) + .balance (key1_receive->balance ().value ().number () - 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_receive->hash ())) .build (); @@ -3576,7 +3576,7 @@ TEST (node, dependency_graph) .from (*key3_open) .previous (key3_open->hash ()) .link (key1_send2->hash ()) - .balance (key3_open->balance ().number () + 1) + .balance (key3_open->balance ().value ().number () + 1) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3_open->hash ())) .build (); @@ -3585,7 +3585,7 @@ TEST (node, dependency_graph) .from (*key3_receive) .previous (key3_receive->hash ()) .link (node.ledger.epoch_link (nano::epoch::epoch_1)) - .balance (key3_receive->balance ()) + .balance (key3_receive->balance ().value ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -3711,7 +3711,7 @@ TEST (node, dependency_graph_frontier) .from (*gen_receive) .previous (gen_receive->hash ()) .link (key2.pub) - .balance (gen_receive->balance ().number () - 2) + .balance (gen_receive->balance ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); @@ -3750,7 +3750,7 @@ TEST (node, dependency_graph_frontier) .from (*key2_send1) .previous (key2_send1->hash ()) .link (key1.pub) - .balance (key2_send1->balance ().number () - 1) + .balance (key2_send1->balance ().value ().number () - 1) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2_send1->hash ())) .build (); @@ -3759,7 +3759,7 @@ TEST (node, dependency_graph_frontier) .from (*key1_send1) .previous (key1_send1->hash ()) .link (key2_send2->hash ()) - .balance (key1_send1->balance ().number () + 1) + .balance (key1_send1->balance ().value ().number () + 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_send1->hash ())) .build (); @@ -3768,7 +3768,7 @@ TEST (node, dependency_graph_frontier) .from (*key1_receive) .previous (key1_receive->hash ()) .link (key3.pub) - .balance (key1_receive->balance ().number () - 1) + .balance (key1_receive->balance ().value ().number () - 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_receive->hash ())) .build (); @@ -3777,7 +3777,7 @@ TEST (node, dependency_graph_frontier) .from (*key3_open) .previous (key3_open->hash ()) .link (key1_send2->hash ()) - .balance (key3_open->balance ().number () + 1) + .balance (key3_open->balance ().value ().number () + 1) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3_open->hash ())) .build (); @@ -3786,7 +3786,7 @@ TEST (node, dependency_graph_frontier) .from (*key3_receive) .previous (key3_receive->hash ()) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) - .balance (key3_receive->balance ()) + .balance (key3_receive->balance ().value ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -3856,7 +3856,7 @@ TEST (node, deferred_dependent_elections) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().number () - 1) + .balance (send1->balance ().value ().number () - 1) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 94f6d8c1b0..7f7a4cabf0 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -461,7 +461,7 @@ TEST (request_aggregator, cannot_vote) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().number () - 1) + .balance (send1->balance ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index c2f5cbc2f5..4256b2415d 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -212,10 +212,9 @@ nano::qualified_root nano::block::qualified_root () const return { root (), previous () }; } -nano::amount const & nano::block::balance () const +std::optional nano::block::balance () const { - static nano::amount amount{ 0 }; - return amount; + return std::nullopt; } void nano::block::operator() (nano::object_stream & obs) const @@ -498,7 +497,7 @@ nano::root const & nano::send_block::root () const return hashables.previous; } -nano::amount const & nano::send_block::balance () const +std::optional nano::send_block::balance () const { return hashables.balance; } @@ -1389,7 +1388,7 @@ nano::account const & nano::state_block::representative () const return hashables.representative; } -nano::amount const & nano::state_block::balance () const +std::optional nano::state_block::balance () const { return hashables.balance; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index f4a47650ef..d492fb89c6 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -46,7 +46,6 @@ class block // Link field for state blocks, zero otherwise. virtual nano::link const & link () const; virtual nano::account const & representative () const; - virtual nano::amount const & balance () const; virtual void serialize (nano::stream &) const = 0; virtual void serialize_json (std::string &, bool = false) const = 0; virtual void serialize_json (boost::property_tree::ptree &) const = 0; @@ -68,6 +67,8 @@ class block nano::account account () const noexcept; // Account field for open/state blocks virtual std::optional account_field () const; + // Balance field for open/send/state blocks + virtual std::optional balance () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -114,7 +115,6 @@ class send_block : public nano::block nano::block_hash const & previous () const override; nano::account const & destination () const override; nano::root const & root () const override; - nano::amount const & balance () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void serialize_json (std::string &, bool = false) const override; @@ -133,6 +133,9 @@ class send_block : public nano::block uint64_t work; static std::size_t constexpr size = nano::send_hashables::size + sizeof (signature) + sizeof (work); +public: // Send block fields + std::optional balance () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; @@ -335,7 +338,6 @@ class state_block : public nano::block nano::root const & root () const override; nano::link const & link () const override; nano::account const & representative () const override; - nano::amount const & balance () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void serialize_json (std::string &, bool = false) const override; @@ -356,6 +358,7 @@ class state_block : public nano::block public: // State block fields std::optional account_field () const override; + std::optional balance () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 1439379839..9789733852 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -303,7 +303,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrtype () == nano::block_type::state || block_a->type () == nano::block_type::send)) { - lazy_balances.emplace (hash, block_a->balance ().number ()); + lazy_balances.emplace (hash, block_a->balance ().value ().number ()); } // Clearing lazy balances for previous block if (!block_a->previous ().is_zero () && lazy_balances.find (block_a->previous ()) != lazy_balances.end ()) @@ -394,7 +394,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state_backlog_check (std::shared_p // Retrieve balance for previous state & send blocks if (block_a->type () == nano::block_type::state || block_a->type () == nano::block_type::send) { - if (block_a->balance ().number () <= next_block.balance) // balance + if (block_a->balance ().value ().number () <= next_block.balance) // balance { lazy_add (next_block.link, next_block.retry_limit); // link } diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 8cf1fe5e40..1a902a402e 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -10,7 +10,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); - block->balance = block_a.balance ().to_string_dec (); + block->balance = block_a.balance ().value ().to_string_dec (); block->link = block_a.link ().to_string (); block->link_as_account = block_a.link ().to_account (); block_a.signature.encode_hex (block->signature); @@ -39,7 +39,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->balance = block_a.balance ().to_string_dec (); + block->balance = block_a.balance ().value ().to_string_dec (); block->destination = block_a.hashables.destination.to_account (); block->previous = block_a.previous ().to_string (); block_a.signature.encode_hex (block->signature); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 5b271232b0..fcb2986558 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -403,7 +403,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) // Send check if (block_previous != nullptr) { - details.is_send = node.ledger.balance (transaction, previous) > block_a.balance ().number (); + details.is_send = node.ledger.balance (transaction, previous) > block_a.balance ().value ().number (); details_found = true; } // Epoch check diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 7477722ed9..7d2da04b24 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -820,7 +820,7 @@ nano::uint128_t nano::ledger::balance (nano::block const & block) break; case nano::block_type::send: case nano::block_type::state: - result = block.balance ().number (); + result = block.balance ().value ().number (); break; case nano::block_type::invalid: case nano::block_type::not_a_block: @@ -995,7 +995,7 @@ bool nano::ledger::is_send (store::transaction const & transaction_a, nano::bloc { if (!previous.is_zero ()) { - if (block_a.balance () < balance (transaction_a, previous)) + if (block_a.balance ().value () < balance (transaction_a, previous)) { result = true; } From c6f506c5f96cc8e93540379922481bf129577576 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 23:38:01 +0000 Subject: [PATCH 159/190] ledger::balance is moved to block::balance and block::balance which accesses the account field is renamed to block::balance_field. --- nano/core_test/active_transactions.cpp | 4 +-- nano/core_test/node.cpp | 32 +++++++++++------------ nano/core_test/request_aggregator.cpp | 2 +- nano/lib/blocks.cpp | 23 +++++++++++++--- nano/lib/blocks.hpp | 8 +++--- nano/node/bootstrap/bootstrap_lazy.cpp | 4 +-- nano/node/ipc/flatbuffers_util.cpp | 4 +-- nano/node/json_handler.cpp | 10 +++---- nano/node/node.cpp | 4 +-- nano/secure/ledger.cpp | 36 +++++--------------------- nano/secure/ledger.hpp | 1 - 11 files changed, 62 insertions(+), 66 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 9f55c40180..a831f9b1b9 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -502,14 +502,14 @@ TEST (active_transactions, inactive_votes_cache_election_start) auto send3 = send_block_builder.make_block () .previous (send2->hash ()) .destination (nano::keypair ().pub) - .balance (send2->balance ().value ().number () - 1) + .balance (send2->balance_field ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); auto send4 = send_block_builder.make_block () .previous (send3->hash ()) .destination (nano::keypair ().pub) - .balance (send3->balance ().value ().number () - 1) + .balance (send3->balance_field ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 0e065baf94..6510565cbf 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3322,7 +3322,7 @@ TEST (node, rollback_vote_self) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().value ().number () - 1) + .balance (send1->balance_field ().value ().number () - 1) .link (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) @@ -3331,7 +3331,7 @@ TEST (node, rollback_vote_self) // fork of send2 block auto fork = builder.make_block () .from (*send2) - .balance (send1->balance ().value ().number () - 2) + .balance (send1->balance_field ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); @@ -3419,7 +3419,7 @@ TEST (node, rollback_gap_source) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().value ().number () - 1) + .balance (send1->balance_field ().value ().number () - 1) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) @@ -3510,7 +3510,7 @@ TEST (node, dependency_graph) .from (*gen_receive) .previous (gen_receive->hash ()) .link (key2.pub) - .balance (gen_receive->balance ().value ().number () - 2) + .balance (gen_receive->balance_field ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); @@ -3549,7 +3549,7 @@ TEST (node, dependency_graph) .from (*key2_send1) .previous (key2_send1->hash ()) .link (key1.pub) - .balance (key2_send1->balance ().value ().number () - 1) + .balance (key2_send1->balance_field ().value ().number () - 1) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2_send1->hash ())) .build (); @@ -3558,7 +3558,7 @@ TEST (node, dependency_graph) .from (*key1_send1) .previous (key1_send1->hash ()) .link (key2_send2->hash ()) - .balance (key1_send1->balance ().value ().number () + 1) + .balance (key1_send1->balance_field ().value ().number () + 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_send1->hash ())) .build (); @@ -3567,7 +3567,7 @@ TEST (node, dependency_graph) .from (*key1_receive) .previous (key1_receive->hash ()) .link (key3.pub) - .balance (key1_receive->balance ().value ().number () - 1) + .balance (key1_receive->balance_field ().value ().number () - 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_receive->hash ())) .build (); @@ -3576,7 +3576,7 @@ TEST (node, dependency_graph) .from (*key3_open) .previous (key3_open->hash ()) .link (key1_send2->hash ()) - .balance (key3_open->balance ().value ().number () + 1) + .balance (key3_open->balance_field ().value ().number () + 1) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3_open->hash ())) .build (); @@ -3585,7 +3585,7 @@ TEST (node, dependency_graph) .from (*key3_receive) .previous (key3_receive->hash ()) .link (node.ledger.epoch_link (nano::epoch::epoch_1)) - .balance (key3_receive->balance ().value ()) + .balance (key3_receive->balance_field ().value ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -3711,7 +3711,7 @@ TEST (node, dependency_graph_frontier) .from (*gen_receive) .previous (gen_receive->hash ()) .link (key2.pub) - .balance (gen_receive->balance ().value ().number () - 2) + .balance (gen_receive->balance_field ().value ().number () - 2) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); @@ -3750,7 +3750,7 @@ TEST (node, dependency_graph_frontier) .from (*key2_send1) .previous (key2_send1->hash ()) .link (key1.pub) - .balance (key2_send1->balance ().value ().number () - 1) + .balance (key2_send1->balance_field ().value ().number () - 1) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2_send1->hash ())) .build (); @@ -3759,7 +3759,7 @@ TEST (node, dependency_graph_frontier) .from (*key1_send1) .previous (key1_send1->hash ()) .link (key2_send2->hash ()) - .balance (key1_send1->balance ().value ().number () + 1) + .balance (key1_send1->balance_field ().value ().number () + 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_send1->hash ())) .build (); @@ -3768,7 +3768,7 @@ TEST (node, dependency_graph_frontier) .from (*key1_receive) .previous (key1_receive->hash ()) .link (key3.pub) - .balance (key1_receive->balance ().value ().number () - 1) + .balance (key1_receive->balance_field ().value ().number () - 1) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_receive->hash ())) .build (); @@ -3777,7 +3777,7 @@ TEST (node, dependency_graph_frontier) .from (*key3_open) .previous (key3_open->hash ()) .link (key1_send2->hash ()) - .balance (key3_open->balance ().value ().number () + 1) + .balance (key3_open->balance_field ().value ().number () + 1) .sign (key3.prv, key3.pub) .work (*system.work.generate (key3_open->hash ())) .build (); @@ -3786,7 +3786,7 @@ TEST (node, dependency_graph_frontier) .from (*key3_receive) .previous (key3_receive->hash ()) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) - .balance (key3_receive->balance ().value ()) + .balance (key3_receive->balance_field ().value ()) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -3856,7 +3856,7 @@ TEST (node, deferred_dependent_elections) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().value ().number () - 1) + .balance (send1->balance_field ().value ().number () - 1) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 7f7a4cabf0..f569c34941 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -461,7 +461,7 @@ TEST (request_aggregator, cannot_vote) auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) - .balance (send1->balance ().value ().number () - 1) + .balance (send1->balance_field ().value ().number () - 1) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 4256b2415d..50b222da5e 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -202,6 +202,23 @@ nano::account nano::block::account () const noexcept } } +nano::amount nano::block::balance () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::open: + case nano::block_type::receive: + case nano::block_type::change: + return sideband ().balance; + case nano::block_type::send: + case nano::block_type::state: + return balance_field ().value (); + default: + release_assert (false); + } +} + std::optional nano::block::account_field () const { return std::nullopt; @@ -212,7 +229,7 @@ nano::qualified_root nano::block::qualified_root () const return { root (), previous () }; } -std::optional nano::block::balance () const +std::optional nano::block::balance_field () const { return std::nullopt; } @@ -497,7 +514,7 @@ nano::root const & nano::send_block::root () const return hashables.previous; } -std::optional nano::send_block::balance () const +std::optional nano::send_block::balance_field () const { return hashables.balance; } @@ -1388,7 +1405,7 @@ nano::account const & nano::state_block::representative () const return hashables.representative; } -std::optional nano::state_block::balance () const +std::optional nano::state_block::balance_field () const { return hashables.balance; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index d492fb89c6..b7b609574b 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -67,8 +67,10 @@ class block nano::account account () const noexcept; // Account field for open/state blocks virtual std::optional account_field () const; + // Returns the balance field or balance from sideband + nano::amount balance () const noexcept; // Balance field for open/send/state blocks - virtual std::optional balance () const; + virtual std::optional balance_field () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -134,7 +136,7 @@ class send_block : public nano::block static std::size_t constexpr size = nano::send_hashables::size + sizeof (signature) + sizeof (work); public: // Send block fields - std::optional balance () const override; + std::optional balance_field () const override; public: // Logging void operator() (nano::object_stream &) const override; @@ -358,7 +360,7 @@ class state_block : public nano::block public: // State block fields std::optional account_field () const override; - std::optional balance () const override; + std::optional balance_field () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 9789733852..edfb5d6477 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -303,7 +303,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrtype () == nano::block_type::state || block_a->type () == nano::block_type::send)) { - lazy_balances.emplace (hash, block_a->balance ().value ().number ()); + lazy_balances.emplace (hash, block_a->balance_field ().value ().number ()); } // Clearing lazy balances for previous block if (!block_a->previous ().is_zero () && lazy_balances.find (block_a->previous ()) != lazy_balances.end ()) @@ -394,7 +394,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state_backlog_check (std::shared_p // Retrieve balance for previous state & send blocks if (block_a->type () == nano::block_type::state || block_a->type () == nano::block_type::send) { - if (block_a->balance ().value ().number () <= next_block.balance) // balance + if (block_a->balance_field ().value ().number () <= next_block.balance) // balance { lazy_add (next_block.link, next_block.retry_limit); // link } diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 1a902a402e..8cf1fe5e40 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -10,7 +10,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); - block->balance = block_a.balance ().value ().to_string_dec (); + block->balance = block_a.balance ().to_string_dec (); block->link = block_a.link ().to_string (); block->link_as_account = block_a.link ().to_account (); block_a.signature.encode_hex (block->signature); @@ -39,7 +39,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->balance = block_a.balance ().value ().to_string_dec (); + block->balance = block_a.balance ().to_string_dec (); block->destination = block_a.hashables.destination.to_account (); block->previous = block_a.previous ().to_string (); block_a.signature.encode_hex (block->signature); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index fcb2986558..3486188a08 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -403,7 +403,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) // Send check if (block_previous != nullptr) { - details.is_send = node.ledger.balance (transaction, previous) > block_a.balance ().value ().number (); + details.is_send = node.ledger.balance (transaction, previous) > block_a.balance_field ().value ().number (); details_found = true; } // Epoch check @@ -1157,8 +1157,8 @@ void nano::json_handler::block_info () { response_l.put ("amount", amount.value ().convert_to ()); } - auto balance = node.ledger.balance (*block); - response_l.put ("balance", balance.convert_to ()); + auto balance = block->balance (); + response_l.put ("balance", balance.number ().convert_to ()); response_l.put ("height", std::to_string (block->sideband ().height)); response_l.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); response_l.put ("successor", block->sideband ().successor.to_string ()); @@ -1314,8 +1314,8 @@ void nano::json_handler::blocks_info () { entry.put ("amount", amount.value ().convert_to ()); } - auto balance = node.ledger.balance (*block); - entry.put ("balance", balance.convert_to ()); + auto balance = block->balance (); + entry.put ("balance", balance.number ().convert_to ()); entry.put ("height", std::to_string (block->sideband ().height)); entry.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); entry.put ("successor", block->sideband ().successor.to_string ()); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 61a1c7fe19..fe292f7f7b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1230,12 +1230,12 @@ void nano::node::process_confirmed_data (store::transaction const & transaction_ // Faster amount calculation auto previous (block_a->previous ()); auto previous_balance = ledger.balance (transaction_a, previous); - auto block_balance = ledger.balance (*block_a); + auto block_balance = block_a->balance (); if (hash_a != ledger.constants.genesis->account ()) { if (previous_balance) { - amount_a = block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; + amount_a = block_balance > previous_balance.value () ? block_balance.number () - previous_balance.value () : previous_balance.value () - block_balance.number (); } else { diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 7d2da04b24..d8deeeb15c 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -480,8 +480,8 @@ void ledger_processor::change_block (nano::change_block & block_a) debug_assert (!validate_message (account, hash, block_a.signature)); block_a.sideband_set (nano::block_sideband (account, 0, info->balance, info->block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); - auto balance = ledger.balance (*previous); - ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance, info->representative, 0 - balance); + auto balance = previous->balance (); + ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance.number (), info->representative, 0 - balance.number ()); nano::account_info new_info (hash, block_a.representative (), info->open_block, info->balance, nano::seconds_since_epoch (), info->block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, *info, new_info); ledger.store.frontier.del (transaction, block_a.hashables.previous); @@ -808,28 +808,6 @@ void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) } } -nano::uint128_t nano::ledger::balance (nano::block const & block) -{ - nano::uint128_t result; - switch (block.type ()) - { - case nano::block_type::open: - case nano::block_type::receive: - case nano::block_type::change: - result = block.sideband ().balance.number (); - break; - case nano::block_type::send: - case nano::block_type::state: - result = block.balance ().value ().number (); - break; - case nano::block_type::invalid: - case nano::block_type::not_a_block: - release_assert (false); - break; - } - return result; -} - // Balance for account containing hash std::optional nano::ledger::balance (store::transaction const & transaction, nano::block_hash const & hash) const { @@ -842,7 +820,7 @@ std::optional nano::ledger::balance (store::transaction const & { return std::nullopt; } - return balance (*block); + return block->balance ().number (); } std::shared_ptr nano::ledger::block (store::transaction const & transaction, nano::block_hash const & hash) const @@ -995,7 +973,7 @@ bool nano::ledger::is_send (store::transaction const & transaction_a, nano::bloc { if (!previous.is_zero ()) { - if (block_a.balance ().value () < balance (transaction_a, previous)) + if (block_a.balance_field ().value () < balance (transaction_a, previous)) { result = true; } @@ -1151,17 +1129,17 @@ std::optional nano::ledger::amount (store::transaction const & { return std::nullopt; } - auto block_balance = balance (*block_l); + auto block_balance = block_l->balance (); if (block_l->previous ().is_zero ()) { - return block_balance; + return block_balance.number (); } auto previous_balance = balance (transaction_a, block_l->previous ()); if (!previous_balance) { return std::nullopt; } - return block_balance > previous_balance.value () ? block_balance - previous_balance.value () : previous_balance.value () - block_balance; + return block_balance > previous_balance.value () ? block_balance.number () - previous_balance.value () : previous_balance.value () - block_balance.number (); } // Return latest block for account diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index bfc1681dc6..fda78dc68b 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -37,7 +37,6 @@ class ledger final std::optional account (store::transaction const &, nano::block_hash const &) const; std::optional account_info (store::transaction const & transaction, nano::account const & account) const; std::optional amount (store::transaction const &, nano::block_hash const &); - static nano::uint128_t balance (nano::block const & block); std::optional balance (store::transaction const &, nano::block_hash const &) const; std::shared_ptr block (store::transaction const & transaction, nano::block_hash const & hash) const; bool block_exists (store::transaction const & transaction, nano::block_hash const & hash) const; From 5dad3a2c563d68bba004f2f4d50e91f98f09b364 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 12:19:49 +0000 Subject: [PATCH 160/190] Change block::destination to return an std::optional if the block actually contains the field. --- nano/core_test/block.cpp | 10 +++++----- nano/lib/blocks.cpp | 7 +++---- nano/lib/blocks.hpp | 6 +++--- nano/node/active_transactions.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/wallet.cpp | 2 +- 7 files changed, 15 insertions(+), 16 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index b187f63bbe..74ff333f79 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -658,7 +658,7 @@ TEST (block_builder, state) .build (ec); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_TRUE (block->destination ().is_zero ()); + ASSERT_FALSE (block->destination ()); ASSERT_EQ (block->link ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } @@ -731,7 +731,7 @@ TEST (block_builder, open) .build (ec); ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); - ASSERT_TRUE (block->destination ().is_zero ()); + ASSERT_FALSE (block->destination ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -770,7 +770,7 @@ TEST (block_builder, change) .build (ec); ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_TRUE (block->destination ().is_zero ()); + ASSERT_FALSE (block->destination ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -809,7 +809,7 @@ TEST (block_builder, send) .build (ec); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_EQ (block->destination ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); + ASSERT_EQ (block->destination ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_TRUE (block->link ().is_zero ()); } @@ -871,6 +871,6 @@ TEST (block_builder, receive) .build (ec); ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); - ASSERT_TRUE (block->destination ().is_zero ()); + ASSERT_FALSE (block->destination ()); ASSERT_TRUE (block->link ().is_zero ()); } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 50b222da5e..d42a32c6b7 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -173,10 +173,9 @@ nano::block_hash const & nano::block::source () const return source; } -nano::account const & nano::block::destination () const +std::optional nano::block::destination () const { - static nano::account destination{}; - return destination; + return std::nullopt; } nano::link const & nano::block::link () const @@ -504,7 +503,7 @@ nano::block_hash const & nano::send_block::previous () const return hashables.previous; } -nano::account const & nano::send_block::destination () const +std::optional nano::send_block::destination () const { return hashables.destination; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index b7b609574b..fe6264967e 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -37,8 +37,6 @@ class block virtual nano::block_hash const & previous () const = 0; // Source block for open/receive blocks, zero otherwise. virtual nano::block_hash const & source () const; - // Destination account for send blocks, zero otherwise. - virtual nano::account const & destination () const; // Previous block or account number for open blocks virtual nano::root const & root () const = 0; // Qualified root value based on previous() and root() @@ -71,6 +69,8 @@ class block nano::amount balance () const noexcept; // Balance field for open/send/state blocks virtual std::optional balance_field () const; + // Destination account for send blocks + virtual std::optional destination () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -115,7 +115,6 @@ class send_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - nano::account const & destination () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -137,6 +136,7 @@ class send_block : public nano::block public: // Send block fields std::optional balance_field () const override; + std::optional destination () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 0b39a6c678..29d47251e4 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -165,7 +165,7 @@ void nano::active_transactions::handle_confirmation (nano::store::read_transacti void nano::active_transactions::handle_block_confirmation (nano::store::read_transaction const & transaction, std::shared_ptr const & block, nano::block_hash const & hash, nano::account & account, nano::uint128_t & amount, bool & is_state_send, bool & is_state_epoch, nano::account & pending_account) { - auto destination = block->link ().is_zero () ? block->destination () : block->link ().as_account (); + auto destination = block->destination () ? block->destination ().value () : block->link ().as_account (); node.receive_confirmed (transaction, hash, destination); node.process_confirmed_data (transaction, block, hash, account, amount, is_state_send, is_state_epoch, pending_account); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index ecbd669855..beb9f1463c 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -344,7 +344,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction { /* block->destination () for legacy send blocks block->link () for state blocks (send subtype) */ - queue_unchecked (transaction_a, block->destination ().is_zero () ? block->link () : block->destination ()); + queue_unchecked (transaction_a, !block->destination () ? block->link () : block->destination ().value ()); } break; } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 33746a1d63..2ea4d02c83 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -148,7 +148,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, switch (block.type ()) { case nano::block_type::send: - destination = block.destination (); + destination = block.destination ().value (); break; case nano::block_type::state: destination = block.link ().as_account (); diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index fde737b85d..6814069ffa 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1092,7 +1092,7 @@ bool nano::wallet::receive_sync (std::shared_ptr const & block_a, n { std::promise result; std::future future = result.get_future (); - auto destination (block_a->link ().is_zero () ? block_a->destination () : block_a->link ().as_account ()); + auto destination (block_a->link ().is_zero () ? block_a->destination ().value () : block_a->link ().as_account ()); receive_async ( block_a->hash (), representative_a, amount_a, destination, [&result] (std::shared_ptr const & block_a) { result.set_value (block_a == nullptr); From 61ad874e112358ad55c328f7d6bd52707c93ece7 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 12:37:53 +0000 Subject: [PATCH 161/190] ledger::destination is moved to block::destination_field and block::destination is created which accesses the the destination field for send blocks. --- nano/core_test/block.cpp | 10 +++++----- nano/lib/blocks.cpp | 19 +++++++++++++++++-- nano/lib/blocks.hpp | 6 ++++-- nano/node/active_transactions.cpp | 6 ++++-- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 22 +++------------------- nano/node/wallet.cpp | 3 +-- 7 files changed, 35 insertions(+), 33 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 74ff333f79..102ace0121 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -658,7 +658,7 @@ TEST (block_builder, state) .build (ec); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_FALSE (block->destination ()); + ASSERT_FALSE (block->destination_field ()); ASSERT_EQ (block->link ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } @@ -731,7 +731,7 @@ TEST (block_builder, open) .build (ec); ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); - ASSERT_FALSE (block->destination ()); + ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -770,7 +770,7 @@ TEST (block_builder, change) .build (ec); ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_FALSE (block->destination ()); + ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -809,7 +809,7 @@ TEST (block_builder, send) .build (ec); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_EQ (block->destination ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); + ASSERT_EQ (block->destination_field ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_TRUE (block->link ().is_zero ()); } @@ -871,6 +871,6 @@ TEST (block_builder, receive) .build (ec); ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); - ASSERT_FALSE (block->destination ()); + ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index d42a32c6b7..cf475af78d 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -173,7 +173,7 @@ nano::block_hash const & nano::block::source () const return source; } -std::optional nano::block::destination () const +std::optional nano::block::destination_field () const { return std::nullopt; } @@ -218,6 +218,21 @@ nano::amount nano::block::balance () const noexcept } } +nano::account nano::block::destination () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::send: + return destination_field ().value (); + case nano::block_type::state: + release_assert (sideband ().details.is_send); + return link ().as_account (); + default: + release_assert (false); + } +} + std::optional nano::block::account_field () const { return std::nullopt; @@ -503,7 +518,7 @@ nano::block_hash const & nano::send_block::previous () const return hashables.previous; } -std::optional nano::send_block::destination () const +std::optional nano::send_block::destination_field () const { return hashables.destination; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index fe6264967e..515e610e5b 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -69,8 +69,10 @@ class block nano::amount balance () const noexcept; // Balance field for open/send/state blocks virtual std::optional balance_field () const; + // Returns the destination account for send/state blocks that are sends + nano::account destination () const noexcept; // Destination account for send blocks - virtual std::optional destination () const; + virtual std::optional destination_field () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -136,7 +138,7 @@ class send_block : public nano::block public: // Send block fields std::optional balance_field () const override; - std::optional destination () const override; + std::optional destination_field () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 29d47251e4..22600bfc6f 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -165,8 +165,10 @@ void nano::active_transactions::handle_confirmation (nano::store::read_transacti void nano::active_transactions::handle_block_confirmation (nano::store::read_transaction const & transaction, std::shared_ptr const & block, nano::block_hash const & hash, nano::account & account, nano::uint128_t & amount, bool & is_state_send, bool & is_state_epoch, nano::account & pending_account) { - auto destination = block->destination () ? block->destination ().value () : block->link ().as_account (); - node.receive_confirmed (transaction, hash, destination); + if (block->sideband ().details.is_send) + { + node.receive_confirmed (transaction, hash, block->destination ()); + } node.process_confirmed_data (transaction, block, hash, account, amount, is_state_send, is_state_epoch, pending_account); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index beb9f1463c..8234295522 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -344,7 +344,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction { /* block->destination () for legacy send blocks block->link () for state blocks (send subtype) */ - queue_unchecked (transaction_a, !block->destination () ? block->link () : block->destination ().value ()); + queue_unchecked (transaction_a, block->destination ()); } break; } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 2ea4d02c83..7a0a3a34a2 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -143,25 +143,9 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, if (is_send) { - // TODO: Encapsulate this as a helper somewhere - nano::account destination{ 0 }; - switch (block.type ()) - { - case nano::block_type::send: - destination = block.destination ().value (); - break; - case nano::block_type::state: - destination = block.link ().as_account (); - break; - default: - debug_assert (false, "unexpected block type"); - break; - } - if (!destination.is_zero ()) - { - accounts.unblock (destination, hash); // Unblocking automatically inserts account into priority set - accounts.priority_up (destination); - } + auto destination = block.destination (); + accounts.unblock (destination, hash); // Unblocking automatically inserts account into priority set + accounts.priority_up (destination); } } break; diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 6814069ffa..e155ecb6c9 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1092,9 +1092,8 @@ bool nano::wallet::receive_sync (std::shared_ptr const & block_a, n { std::promise result; std::future future = result.get_future (); - auto destination (block_a->link ().is_zero () ? block_a->destination ().value () : block_a->link ().as_account ()); receive_async ( - block_a->hash (), representative_a, amount_a, destination, [&result] (std::shared_ptr const & block_a) { + block_a->hash (), representative_a, amount_a, block_a->destination (), [&result] (std::shared_ptr const & block_a) { result.set_value (block_a == nullptr); }, true); From fa81fc01ccef77b90c2ba271c8efe84c5112afc3 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 13:19:52 +0000 Subject: [PATCH 162/190] Change block::source to return an std::optional if the block actually contains the field. --- nano/core_test/block.cpp | 10 +++++----- nano/core_test/ledger.cpp | 6 +++--- nano/core_test/unchecked_map.cpp | 4 ++-- nano/lib/blocks.cpp | 9 ++++----- nano/lib/blocks.hpp | 10 ++++++---- nano/node/bootstrap/bootstrap_lazy.cpp | 4 ++-- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 7 +------ nano/node/confirmation_height_unbounded.cpp | 7 +------ nano/node/ipc/flatbuffers_util.cpp | 4 ++-- nano/secure/ledger.cpp | 8 ++++---- 11 files changed, 31 insertions(+), 40 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 102ace0121..d6640ffe9f 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -657,7 +657,7 @@ TEST (block_builder, state) .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86") .build (ec); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); - ASSERT_TRUE (block->source ().is_zero ()); + ASSERT_FALSE (block->source ()); ASSERT_FALSE (block->destination_field ()); ASSERT_EQ (block->link ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } @@ -730,7 +730,7 @@ TEST (block_builder, open) .source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA") .build (ec); ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); - ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); + ASSERT_EQ (block->source ().value ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -769,7 +769,7 @@ TEST (block_builder, change) .previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456") .build (ec); ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); - ASSERT_TRUE (block->source ().is_zero ()); + ASSERT_FALSE (block->source ()); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -808,7 +808,7 @@ TEST (block_builder, send) .balance_hex ("00F035A9C7D818E7C34148C524FFFFEE") .build (ec); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); - ASSERT_TRUE (block->source ().is_zero ()); + ASSERT_FALSE (block->source ()); ASSERT_EQ (block->destination_field ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_TRUE (block->link ().is_zero ()); } @@ -870,7 +870,7 @@ TEST (block_builder, receive) .source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135") .build (ec); ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); - ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); + ASSERT_EQ (block->source ().value ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index be50f1eec0..ffdecf6682 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -4344,7 +4344,7 @@ TEST (ledger, unchecked_open) // Waits for the last blocks to pass through block_processor and unchecked.put queues ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); // Get the next peer for attempting a tcp bootstrap connection - auto blocks = node1.unchecked.get (open1->source ()); + auto blocks = node1.unchecked.get (open1->source ().value ()); ASSERT_EQ (blocks.size (), 1); } node1.block_processor.add (send1); @@ -4412,11 +4412,11 @@ TEST (ledger, unchecked_receive) } // Waits for the open1 block to pass through block_processor and unchecked.put queues node1.block_processor.add (open1); - ASSERT_TIMELY (15s, check_block_is_listed (node1.store.tx_begin_read (), receive1->source ())); + ASSERT_TIMELY (15s, check_block_is_listed (node1.store.tx_begin_read (), receive1->source ().value ())); // Previous block for receive1 is known, signature was validated { auto transaction = node1.store.tx_begin_read (); - auto blocks (node1.unchecked.get (receive1->source ())); + auto blocks (node1.unchecked.get (receive1->source ().value ())); ASSERT_EQ (blocks.size (), 1); } node1.block_processor.add (send2); diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 105ee31318..99777f653b 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -147,14 +147,14 @@ TEST (unchecked, multiple) // Enqueues the first block unchecked.put (block->previous (), nano::unchecked_info (block)); // Enqueues a second block - unchecked.put (block->source (), nano::unchecked_info (block)); + unchecked.put (6, nano::unchecked_info (block)); auto check_block_is_listed = [&] (nano::block_hash const & block_hash_a) { return unchecked.get (block_hash_a).size () > 0; }; // Waits for and asserts the first block gets saved in the database ASSERT_TIMELY (5s, check_block_is_listed (block->previous ())); // Waits for and asserts the second block gets saved in the database - ASSERT_TIMELY (5s, check_block_is_listed (block->source ())); + ASSERT_TIMELY (5s, check_block_is_listed (6)); } // This test ensures that a block can't occur twice in the unchecked table. diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index cf475af78d..07af4a1a31 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -167,10 +167,9 @@ nano::account const & nano::block::representative () const return representative; } -nano::block_hash const & nano::block::source () const +std::optional nano::block::source () const { - static nano::block_hash source{ 0 }; - return source; + return std::nullopt; } std::optional nano::block::destination_field () const @@ -809,7 +808,7 @@ bool nano::open_block::valid_predecessor (nano::block const & block_a) const return false; } -nano::block_hash const & nano::open_block::source () const +std::optional nano::open_block::source () const { return hashables.source; } @@ -1746,7 +1745,7 @@ nano::block_hash const & nano::receive_block::previous () const return hashables.previous; } -nano::block_hash const & nano::receive_block::source () const +std::optional nano::receive_block::source () const { return hashables.source; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 515e610e5b..0e97607632 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -35,8 +35,6 @@ class block virtual void block_work_set (uint64_t) = 0; // Previous block in account's chain, zero for open block virtual nano::block_hash const & previous () const = 0; - // Source block for open/receive blocks, zero otherwise. - virtual nano::block_hash const & source () const; // Previous block or account number for open blocks virtual nano::root const & root () const = 0; // Qualified root value based on previous() and root() @@ -73,6 +71,8 @@ class block nano::account destination () const noexcept; // Destination account for send blocks virtual std::optional destination_field () const; + // Source block for open/receive blocks + virtual std::optional source () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -170,7 +170,6 @@ class receive_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - nano::block_hash const & source () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -190,6 +189,9 @@ class receive_block : public nano::block uint64_t work; static std::size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); +public: // Receive block fields + std::optional source () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; @@ -222,7 +224,6 @@ class open_block : public nano::block uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - nano::block_hash const & source () const override; nano::root const & root () const override; nano::account const & representative () const override; void serialize (nano::stream &) const override; @@ -245,6 +246,7 @@ class open_block : public nano::block public: // Open block fields std::optional account_field () const override; + std::optional source () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index edfb5d6477..36b73eadbe 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -291,9 +291,9 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrsource ().is_zero () && !node->ledger.block_or_pruned_exists (block_a->source ()) && block_a->source () != node->network_params.ledger.genesis->account ()) + if (block_a->source () && !node->ledger.block_or_pruned_exists (block_a->source ().value ()) && block_a->source ().value () != node->network_params.ledger.genesis->account ()) { - lazy_add (block_a->source (), retry_limit); + lazy_add (block_a->source ().value (), retry_limit); } else if (block_a->type () == nano::block_type::state) { diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 7a0a3a34a2..945b263abd 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -152,7 +152,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, case nano::block_status::gap_source: { const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value (); - const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); + const auto source = !block.source () ? block.link ().as_block_hash () : block.source ().value (); // Mark account as blocked because it is missing the source block accounts.block (account, source); diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 68faaf07a8..866dc2521b 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -253,12 +253,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; auto block = ledger.block (transaction_a, hash); - auto source (block->source ()); - if (source.is_zero ()) - { - source = block->link ().as_block_hash (); - } - + auto source = block->source ().value_or (block->link ().as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { hit_receive = true; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index b93fc63547..d1975d6e10 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -212,12 +212,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source if (block) { - auto source (block->source ()); - if (source.is_zero ()) - { - source = block->link ().as_block_hash (); - } - + auto source = block->source ().value_or (block->link ().as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { if (!hit_receive && !block_callback_data_a.empty ()) diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 8cf1fe5e40..a7785467b9 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -51,7 +51,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (na { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->source = block_a.source ().to_string (); + block->source = block_a.source ().value ().to_string (); block->previous = block_a.previous ().to_string (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); @@ -62,7 +62,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->source = block_a.source ().to_string (); + block->source = block_a.source ().value ().to_string (); block->account = block_a.account ().to_account (); block->representative = block_a.representative ().to_account (); block_a.signature.encode_hex (block->signature); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index d8deeeb15c..1f0a652387 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1009,7 +1009,7 @@ nano::block_hash nano::ledger::block_source (store::transaction const & transact // If block_a.source () is nonzero, then we have our source. // However, universal blocks will always return zero. - nano::block_hash result (block_a.source ()); + nano::block_hash result = block_a.source ().value_or (0); nano::state_block const * state_block (dynamic_cast (&block_a)); if (state_block != nullptr && !is_send (transaction_a, *state_block)) { @@ -1210,13 +1210,13 @@ class dependent_block_visitor : public nano::block_visitor void receive_block (nano::receive_block const & block_a) override { result[0] = block_a.previous (); - result[1] = block_a.source (); + result[1] = block_a.source ().value (); } void open_block (nano::open_block const & block_a) override { if (block_a.source () != ledger.constants.genesis->account ()) { - result[0] = block_a.source (); + result[0] = block_a.source ().value (); } } void change_block (nano::change_block const & block_a) override @@ -1266,7 +1266,7 @@ std::shared_ptr nano::ledger::find_receive_block_by_send_hash (stor while (possible_receive_block != nullptr) { // if source is non-zero then it is a legacy receive or open block - nano::block_hash source = possible_receive_block->source (); + nano::block_hash source = possible_receive_block->source ().value_or (0); // if source is zero then it could be a state block, which needs a different kind of access auto state_block = dynamic_cast (possible_receive_block.get ()); From b66bfe2a2c0ef0485b5343aff32f171f948e601a Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 14:17:06 +0000 Subject: [PATCH 163/190] ledger::source is moved to block::source_field and ledger::block_source is moved to block::source which accesses the source field for open/receive/state blocks that are receives. --- nano/core_test/block.cpp | 10 ++--- nano/core_test/ledger.cpp | 18 ++++----- nano/lib/blocks.cpp | 22 +++++++++-- nano/lib/blocks.hpp | 8 ++-- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap/bootstrap_lazy.cpp | 4 +- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 4 +- nano/node/json_handler.cpp | 14 +++---- nano/secure/ledger.cpp | 43 ++------------------- nano/secure/ledger.hpp | 1 - 13 files changed, 57 insertions(+), 75 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index d6640ffe9f..1f04bb680d 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -657,7 +657,7 @@ TEST (block_builder, state) .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86") .build (ec); ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); - ASSERT_FALSE (block->source ()); + ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); ASSERT_EQ (block->link ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } @@ -730,7 +730,7 @@ TEST (block_builder, open) .source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA") .build (ec); ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); - ASSERT_EQ (block->source ().value ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); + ASSERT_EQ (block->source_field ().value ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -769,7 +769,7 @@ TEST (block_builder, change) .previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456") .build (ec); ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); - ASSERT_FALSE (block->source ()); + ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } @@ -808,7 +808,7 @@ TEST (block_builder, send) .balance_hex ("00F035A9C7D818E7C34148C524FFFFEE") .build (ec); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); - ASSERT_FALSE (block->source ()); + ASSERT_FALSE (block->source_field ()); ASSERT_EQ (block->destination_field ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_TRUE (block->link ().is_zero ()); } @@ -870,7 +870,7 @@ TEST (block_builder, receive) .source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135") .build (ec); ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); - ASSERT_EQ (block->source ().value ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); + ASSERT_EQ (block->source_field ().value ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); ASSERT_FALSE (block->destination_field ()); ASSERT_TRUE (block->link ().is_zero ()); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index ffdecf6682..35c44d4faf 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2329,17 +2329,17 @@ TEST (ledger, block_destination_source) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); - ASSERT_TRUE (ledger.block_source (transaction, *block1).is_zero ()); + ASSERT_FALSE (block1->source_field ()); ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block2)); - ASSERT_TRUE (ledger.block_source (transaction, *block2).is_zero ()); + ASSERT_FALSE (block2->source_field ()); ASSERT_EQ (ledger.block_destination (transaction, *block3), nullptr); - ASSERT_EQ (block2->hash (), ledger.block_source (transaction, *block3)); + ASSERT_EQ (block2->hash (), block3->source ()); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block4)); - ASSERT_TRUE (ledger.block_source (transaction, *block4).is_zero ()); + ASSERT_FALSE (block4->source_field ()); ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block5)); - ASSERT_TRUE (ledger.block_source (transaction, *block5).is_zero ()); + ASSERT_FALSE (block5->source_field ()); ASSERT_EQ (ledger.block_destination (transaction, *block6), nullptr); - ASSERT_EQ (block5->hash (), ledger.block_source (transaction, *block6)); + ASSERT_EQ (block5->hash (), block6->source ()); } TEST (ledger, state_account) @@ -4344,7 +4344,7 @@ TEST (ledger, unchecked_open) // Waits for the last blocks to pass through block_processor and unchecked.put queues ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); // Get the next peer for attempting a tcp bootstrap connection - auto blocks = node1.unchecked.get (open1->source ().value ()); + auto blocks = node1.unchecked.get (open1->source_field ().value ()); ASSERT_EQ (blocks.size (), 1); } node1.block_processor.add (send1); @@ -4412,11 +4412,11 @@ TEST (ledger, unchecked_receive) } // Waits for the open1 block to pass through block_processor and unchecked.put queues node1.block_processor.add (open1); - ASSERT_TIMELY (15s, check_block_is_listed (node1.store.tx_begin_read (), receive1->source ().value ())); + ASSERT_TIMELY (15s, check_block_is_listed (node1.store.tx_begin_read (), receive1->source_field ().value ())); // Previous block for receive1 is known, signature was validated { auto transaction = node1.store.tx_begin_read (); - auto blocks (node1.unchecked.get (receive1->source ().value ())); + auto blocks (node1.unchecked.get (receive1->source_field ().value ())); ASSERT_EQ (blocks.size (), 1); } node1.block_processor.add (send2); diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 07af4a1a31..22022cad6c 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -167,7 +167,7 @@ nano::account const & nano::block::representative () const return representative; } -std::optional nano::block::source () const +std::optional nano::block::source_field () const { return std::nullopt; } @@ -232,6 +232,22 @@ nano::account nano::block::destination () const noexcept } } +nano::block_hash nano::block::source () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::open: + case nano::block_type::receive: + return source_field ().value (); + case nano::block_type::state: + release_assert (sideband ().details.is_receive); + return link ().as_block_hash (); + default: + release_assert (false); + } +} + std::optional nano::block::account_field () const { return std::nullopt; @@ -808,7 +824,7 @@ bool nano::open_block::valid_predecessor (nano::block const & block_a) const return false; } -std::optional nano::open_block::source () const +std::optional nano::open_block::source_field () const { return hashables.source; } @@ -1745,7 +1761,7 @@ nano::block_hash const & nano::receive_block::previous () const return hashables.previous; } -std::optional nano::receive_block::source () const +std::optional nano::receive_block::source_field () const { return hashables.source; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 0e97607632..081d204384 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -71,8 +71,10 @@ class block nano::account destination () const noexcept; // Destination account for send blocks virtual std::optional destination_field () const; + // Returns the source block hash for open/receive/state blocks that are receives + nano::block_hash source () const noexcept; // Source block for open/receive blocks - virtual std::optional source () const; + virtual std::optional source_field () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -190,7 +192,7 @@ class receive_block : public nano::block static std::size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); public: // Receive block fields - std::optional source () const override; + std::optional source_field () const override; public: // Logging void operator() (nano::object_stream &) const override; @@ -246,7 +248,7 @@ class open_block : public nano::block public: // Open block fields std::optional account_field () const override; - std::optional source () const override; + std::optional source_field () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 8234295522..2ad55c09cc 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -356,7 +356,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } case nano::block_status::gap_source: { - node.unchecked.put (node.ledger.block_source (transaction_a, *block), block); + node.unchecked.put (block->source_field ().value_or (block->link ().as_block_hash ()), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 36b73eadbe..45e9cab61e 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -291,9 +291,9 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrsource () && !node->ledger.block_or_pruned_exists (block_a->source ().value ()) && block_a->source ().value () != node->network_params.ledger.genesis->account ()) + if (block_a->source_field () && !node->ledger.block_or_pruned_exists (block_a->source_field ().value ()) && block_a->source_field ().value () != node->network_params.ledger.genesis->account ()) { - lazy_add (block_a->source ().value (), retry_limit); + lazy_add (block_a->source_field ().value (), retry_limit); } else if (block_a->type () == nano::block_type::state) { diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 945b263abd..0643fd3149 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -152,7 +152,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, case nano::block_status::gap_source: { const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value (); - const auto source = !block.source () ? block.link ().as_block_hash () : block.source ().value (); + const auto source = block.source_field ().value_or (block.link ().as_block_hash ()); // Mark account as blocked because it is missing the source block accounts.block (account, source); diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 866dc2521b..cce7747a9d 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -253,7 +253,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; auto block = ledger.block (transaction_a, hash); - auto source = block->source ().value_or (block->link ().as_block_hash ()); + auto source = block->source_field ().value_or (block->link ().as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { hit_receive = true; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index d1975d6e10..61aa6a9591 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -212,7 +212,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source if (block) { - auto source = block->source ().value_or (block->link ().as_block_hash ()); + auto source = block->source_field ().value_or (block->link ().as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { if (!hit_receive && !block_callback_data_a.empty ()) diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index a7785467b9..57afdecf33 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -51,7 +51,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (na { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->source = block_a.source ().value ().to_string (); + block->source = block_a.source_field ().value ().to_string (); block->previous = block_a.previous ().to_string (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); @@ -62,7 +62,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: { auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); - block->source = block_a.source ().value ().to_string (); + block->source = block_a.source_field ().value ().to_string (); block->account = block_a.account ().to_account (); block->representative = block_a.representative ().to_account (); block_a.signature.encode_hex (block->signature); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 3486188a08..8c5acd755d 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1383,15 +1383,15 @@ void nano::json_handler::blocks_info () } if (source) { - nano::block_hash source_hash (node.ledger.block_source (transaction, *block)); - auto block_a = node.ledger.block (transaction, source_hash); - if (block_a != nullptr) + if (!block->sideband ().details.is_receive || !node.ledger.block_exists (transaction, block->source ())) { - entry.put ("source_account", block_a->account ().to_account ()); + entry.put ("source_account", "0"); } else { - entry.put ("source_account", "0"); + auto block_a = node.ledger.block (transaction, block->source ()); + release_assert (block_a); + entry.put ("source_account", block_a->account ().to_account ()); } } blocks.push_back (std::make_pair (hash_text, entry)); @@ -3641,7 +3641,7 @@ void nano::json_handler::republish () block = node.ledger.block (transaction, hash); if (sources != 0) // Republish source chain { - nano::block_hash source (node.ledger.block_source (transaction, *block)); + nano::block_hash source = block->source_field ().value_or (block->link ().as_block_hash ()); auto block_a = node.ledger.block (transaction, source); std::vector hashes; while (block_a != nullptr && hashes.size () < sources) @@ -3679,7 +3679,7 @@ void nano::json_handler::republish () while (block_d != nullptr && hash != source) { hashes.push_back (previous); - source = node.ledger.block_source (transaction, *block_d); + source = block_d->source_field ().value_or (block_d->sideband ().details.is_send ? 0 : block_d->link ().as_block_hash ()); previous = block_d->previous (); block_d = node.ledger.block (transaction, previous); } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 1f0a652387..d35a03d40a 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -998,26 +998,6 @@ nano::account const & nano::ledger::block_destination (store::transaction const return nano::account::null (); } -nano::block_hash nano::ledger::block_source (store::transaction const & transaction_a, nano::block const & block_a) -{ - /* - * block_source() requires that the previous block of the block - * passed in exist in the database. This is because it will try - * to check account balances to determine if it is a send block. - */ - debug_assert (block_a.previous ().is_zero () || 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. - nano::block_hash result = block_a.source ().value_or (0); - nano::state_block const * state_block (dynamic_cast (&block_a)); - if (state_block != nullptr && !is_send (transaction_a, *state_block)) - { - result = state_block->hashables.link.as_block_hash (); - } - return result; -} - std::pair nano::ledger::hash_root_random (store::transaction const & transaction_a) const { nano::block_hash hash (0); @@ -1210,13 +1190,13 @@ class dependent_block_visitor : public nano::block_visitor void receive_block (nano::receive_block const & block_a) override { result[0] = block_a.previous (); - result[1] = block_a.source ().value (); + result[1] = block_a.source_field ().value (); } void open_block (nano::open_block const & block_a) override { - if (block_a.source () != ledger.constants.genesis->account ()) + if (block_a.source_field ().value () != ledger.constants.genesis->account ()) { - result[0] = block_a.source ().value (); + result[0] = block_a.source_field ().value (); } } void change_block (nano::change_block const & block_a) override @@ -1265,22 +1245,7 @@ std::shared_ptr nano::ledger::find_receive_block_by_send_hash (stor // walk down the chain until the source field of a receive block matches the send block hash while (possible_receive_block != nullptr) { - // if source is non-zero then it is a legacy receive or open block - nano::block_hash source = possible_receive_block->source ().value_or (0); - - // if source is zero then it could be a state block, which needs a different kind of access - auto state_block = dynamic_cast (possible_receive_block.get ()); - if (state_block != nullptr) - { - // we read the block from the database, so we expect it to have sideband - debug_assert (state_block->has_sideband ()); - if (state_block->sideband ().details.is_receive) - { - source = state_block->hashables.link.as_block_hash (); - } - } - - if (send_block_hash == source) + if (possible_receive_block->sideband ().details.is_receive && send_block_hash == possible_receive_block->source ()) { // we have a match result = possible_receive_block; diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index fda78dc68b..229c86b8d4 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -58,7 +58,6 @@ class ledger final std::string block_text (nano::block_hash const &); bool is_send (store::transaction const &, nano::block const &) const; nano::account const & block_destination (store::transaction const &, nano::block const &); - nano::block_hash block_source (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; nano::block_status process (store::write_transaction const & transaction, std::shared_ptr block); From 4b2f574c8a2496431986a7c01cb0f2fd91b22430 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 15:29:53 +0000 Subject: [PATCH 164/190] Change block::link to return an std::optional if the block actually contains the field. --- nano/core_test/block.cpp | 10 +++---- nano/core_test/wallet.cpp | 12 ++++----- nano/core_test/wallets.cpp | 2 +- nano/lib/blocks.cpp | 11 ++++---- nano/lib/blocks.hpp | 6 ++--- nano/nano_node/entry.cpp | 12 ++++----- nano/node/blockprocessor.cpp | 3 ++- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 6 ++--- nano/node/json_handler.cpp | 16 +++++------ nano/node/node.cpp | 6 ++--- nano/node/websocket.cpp | 4 +-- nano/rpc_test/receivable.cpp | 30 ++++++++++----------- nano/rpc_test/rpc.cpp | 22 +++++++-------- nano/secure/ledger.cpp | 2 +- 17 files changed, 74 insertions(+), 74 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 1f04bb680d..cab5e34a2d 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -659,7 +659,7 @@ TEST (block_builder, state) ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); - ASSERT_EQ (block->link ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); + ASSERT_EQ (block->link ().value ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } TEST (block_builder, state_missing_rep) @@ -732,7 +732,7 @@ TEST (block_builder, open) ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); ASSERT_EQ (block->source_field ().value ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); ASSERT_FALSE (block->destination_field ()); - ASSERT_TRUE (block->link ().is_zero ()); + ASSERT_FALSE (block->link ()); } TEST (block_builder, open_equality) @@ -771,7 +771,7 @@ TEST (block_builder, change) ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); - ASSERT_TRUE (block->link ().is_zero ()); + ASSERT_FALSE (block->link ()); } TEST (block_builder, change_equality) @@ -810,7 +810,7 @@ TEST (block_builder, send) ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_FALSE (block->source_field ()); ASSERT_EQ (block->destination_field ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); - ASSERT_TRUE (block->link ().is_zero ()); + ASSERT_FALSE (block->link ()); } TEST (block_builder, send_equality) @@ -872,5 +872,5 @@ TEST (block_builder, receive) ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); ASSERT_EQ (block->source_field ().value ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); ASSERT_FALSE (block->destination_field ()); - ASSERT_TRUE (block->link ().is_zero ()); + ASSERT_FALSE (block->link ()); } diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index ab107d56a4..c1a56fc5d5 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1001,7 +1001,7 @@ TEST (wallet, epoch_2_validation) ASSERT_EQ (nano::epoch::epoch_2, send->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send->sideband ().source_epoch); // Not used for send state blocks - auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().as_account (), 1); + auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().value ().as_account (), 1); ASSERT_NE (nullptr, receive); if (nano::dev::network_params.work.difficulty (*receive) < node.network_params.work.base) { @@ -1043,7 +1043,7 @@ TEST (wallet, epoch_2_receive_propagation) auto amount = node.config.receive_minimum.number (); auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send1); - ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->link ().as_account (), 1)); + ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->link ().value ().as_account (), 1)); // Upgrade the genesis account to epoch 2 auto epoch2 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_2); @@ -1053,7 +1053,7 @@ TEST (wallet, epoch_2_receive_propagation) auto send2 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send2); - auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().as_account (), 1); + auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().value ().as_account (), 1); ASSERT_NE (nullptr, receive2); if (nano::dev::network_params.work.difficulty (*receive2) < node.network_params.work.base) { @@ -1106,7 +1106,7 @@ TEST (wallet, epoch_2_receive_unopened) wallet.insert_adhoc (key.prv, false); - auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->link ().as_account (), 1); + auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->link ().value ().as_account (), 1); ASSERT_NE (nullptr, receive1); if (nano::dev::network_params.work.difficulty (*receive1) < node.network_params.work.base) { @@ -1190,7 +1190,7 @@ TEST (wallet, search_receivable) auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); - ASSERT_EQ (send->hash (), receive->link ().as_block_hash ()); + ASSERT_EQ (send->hash (), receive->link ().value ().as_block_hash ()); } TEST (wallet, receive_pruned) @@ -1228,7 +1228,7 @@ TEST (wallet, receive_pruned) wallet2.insert_adhoc (key.prv, false); - auto open1 = wallet2.receive_action (send1->hash (), key.pub, amount, send1->link ().as_account (), 1); + auto open1 = wallet2.receive_action (send1->hash (), key.pub, amount, send1->link ().value ().as_account (), 1); ASSERT_NE (nullptr, open1); ASSERT_EQ (amount, node2.ledger.balance (node2.store.tx_begin_read (), open1->hash ())); ASSERT_TIMELY_EQ (5s, node2.ledger.cache.cemented_count, 4); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index bbff7d287d..c596cad9c5 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -254,6 +254,6 @@ TEST (wallets, search_receivable) auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); - ASSERT_EQ (send->hash (), receive->link ().as_block_hash ()); + ASSERT_EQ (send->hash (), receive->link ().value ().as_block_hash ()); } } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 22022cad6c..1d1f19e3d2 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -177,10 +177,9 @@ std::optional nano::block::destination_field () const return std::nullopt; } -nano::link const & nano::block::link () const +std::optional nano::block::link () const { - static nano::link link{ 0 }; - return link; + return std::nullopt; } nano::account nano::block::account () const noexcept @@ -226,7 +225,7 @@ nano::account nano::block::destination () const noexcept return destination_field ().value (); case nano::block_type::state: release_assert (sideband ().details.is_send); - return link ().as_account (); + return link ().value ().as_account (); default: release_assert (false); } @@ -242,7 +241,7 @@ nano::block_hash nano::block::source () const noexcept return source_field ().value (); case nano::block_type::state: release_assert (sideband ().details.is_receive); - return link ().as_block_hash (); + return link ().value ().as_block_hash (); default: release_assert (false); } @@ -1424,7 +1423,7 @@ nano::root const & nano::state_block::root () const } } -nano::link const & nano::state_block::link () const +std::optional nano::state_block::link () const { return hashables.link; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 081d204384..b67bf3c91e 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -39,8 +39,6 @@ class block virtual nano::root const & root () const = 0; // Qualified root value based on previous() and root() virtual nano::qualified_root qualified_root () const; - // Link field for state blocks, zero otherwise. - virtual nano::link const & link () const; virtual nano::account const & representative () const; virtual void serialize (nano::stream &) const = 0; virtual void serialize_json (std::string &, bool = false) const = 0; @@ -71,6 +69,8 @@ class block nano::account destination () const noexcept; // Destination account for send blocks virtual std::optional destination_field () const; + // Link field for state blocks + virtual std::optional link () const; // Returns the source block hash for open/receive/state blocks that are receives nano::block_hash source () const noexcept; // Source block for open/receive blocks @@ -344,7 +344,6 @@ class state_block : public nano::block void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; nano::root const & root () const override; - nano::link const & link () const override; nano::account const & representative () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -367,6 +366,7 @@ class state_block : public nano::block public: // State block fields std::optional account_field () const override; std::optional balance_field () const override; + std::optional link () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 3c5b79a6b8..a01d25b1f9 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1501,7 +1501,7 @@ int main (int argc, char * const * argv) { if ((state_block.hashables.balance == prev_balance && !error_or_pruned) || (node->ledger.pruning && error_or_pruned && block->sideband ().details.is_epoch)) { - invalid = validate_message (node->ledger.epoch_signer (block->link ()), hash, block->block_signature ()); + invalid = validate_message (node->ledger.epoch_signer (block->link ().value ()), hash, block->block_signature ()); } } } @@ -1529,12 +1529,12 @@ int main (int argc, char * const * argv) } else { - if (block->link ().is_zero ()) + if (block->link ().value ().is_zero ()) { // State change block_details_error = sideband.details.is_send || sideband.details.is_receive || sideband.details.is_epoch; } - else if (block->balance () == prev_balance.value () && node->ledger.is_epoch_link (block->link ())) + else if (block->balance () == prev_balance.value () && node->ledger.is_epoch_link (block->link ().value ())) { // State epoch block_details_error = !sideband.details.is_epoch || sideband.details.is_send || sideband.details.is_receive; @@ -1543,7 +1543,7 @@ int main (int argc, char * const * argv) { // State receive block_details_error = !sideband.details.is_receive || sideband.details.is_send || sideband.details.is_epoch; - block_details_error |= !node->ledger.block_or_pruned_exists (transaction, block->link ().as_block_hash ()); + block_details_error |= !node->ledger.block_or_pruned_exists (transaction, block->link ().value ().as_block_hash ()); } } } @@ -1557,7 +1557,7 @@ int main (int argc, char * const * argv) print_error_message (boost::str (boost::format ("Incorrect sideband block details for block %1%\n") % hash.to_string ())); } // Check link epoch version - if (sideband.details.is_receive && (!node->ledger.pruning || !node->store.pruned.exists (transaction, block->link ().as_block_hash ()))) + if (sideband.details.is_receive && (!node->ledger.pruning || !node->store.pruned.exists (transaction, block->source ()))) { if (sideband.source_epoch != node->ledger.version (*block)) { @@ -1809,7 +1809,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("%1% blocks retrieved") % count) << std::endl; } node.node->block_processor.add (block); - if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link ())) + if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link ().value ())) { // Epoch open blocks can be rejected without processed pending blocks to account, push it later again epoch_open_blocks.push_back (block); diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 2ad55c09cc..d968a312e2 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -356,7 +356,8 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } case nano::block_status::gap_source: { - node.unchecked.put (block->source_field ().value_or (block->link ().as_block_hash ()), block); + release_assert (block->source_field () || block->link ()); + node.unchecked.put (block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 0643fd3149..a614f0e34b 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -152,7 +152,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, case nano::block_status::gap_source: { const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value (); - const auto source = block.source_field ().value_or (block.link ().as_block_hash ()); + const auto source = block.source_field ().value_or (block.link ().value_or (0).as_block_hash ()); // Mark account as blocked because it is missing the source block accounts.block (account, source); diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index cce7747a9d..459b835abb 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -253,7 +253,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; auto block = ledger.block (transaction_a, hash); - auto source = block->source_field ().value_or (block->link ().as_block_hash ()); + auto source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { hit_receive = true; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 61aa6a9591..807743b76b 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -212,7 +212,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source if (block) { - auto source = block->source_field ().value_or (block->link ().as_block_hash ()); + auto source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) { if (!hit_receive && !block_callback_data_a.empty ()) diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 57afdecf33..de252a0792 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -11,8 +11,8 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); block->balance = block_a.balance ().to_string_dec (); - block->link = block_a.link ().to_string (); - block->link_as_account = block_a.link ().to_account (); + block->link = block_a.link ().value ().to_string (); + block->link_as_account = block_a.link ().value ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); @@ -20,7 +20,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano { block->subtype = nanoapi::BlockSubType::BlockSubType_send; } - else if (block_a.link ().is_zero ()) + else if (block_a.link ().value ().is_zero ()) { block->subtype = nanoapi::BlockSubType::BlockSubType_change; } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 8c5acd755d..8a5e185fc6 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -411,12 +411,12 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) { details.epoch = block_previous->sideband ().details.epoch; } - auto link (block_a.link ()); - if (!link.is_zero () && !details.is_send) + auto link = block_a.link (); + if (link && !details.is_send) { - auto block_link = node.ledger.block (transaction, link.as_block_hash ()); + auto block_link = node.ledger.block (transaction, link.value ().as_block_hash ()); auto account = block_a.account_field ().value (); // Link is non-zero therefore it's a state block and has an account field; - if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (account, link.as_block_hash ()))) + if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (account, link.value ().as_block_hash ()))) { details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); details.is_receive = true; @@ -1224,7 +1224,7 @@ void nano::json_handler::block_confirm () if (auto state = dynamic_cast (block_l.get ())) { is_state_send = node.ledger.is_send (transaction, *state); - is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link ()); + is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link ().value ()); } } node.observers.blocks.notify (status, {}, account, amount ? amount.value () : 0, is_state_send, is_state_epoch); @@ -2522,7 +2522,7 @@ class history_visitor : public nano::block_visitor if (raw && accounts_filter.empty ()) { tree.put ("subtype", "epoch"); - tree.put ("account", handler.node.ledger.epoch_signer (block_a.link ()).to_account ()); + tree.put ("account", handler.node.ledger.epoch_signer (block_a.link ().value ()).to_account ()); } } else @@ -3641,7 +3641,7 @@ void nano::json_handler::republish () block = node.ledger.block (transaction, hash); if (sources != 0) // Republish source chain { - nano::block_hash source = block->source_field ().value_or (block->link ().as_block_hash ()); + nano::block_hash source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); auto block_a = node.ledger.block (transaction, source); std::vector hashes; while (block_a != nullptr && hashes.size () < sources) @@ -3679,7 +3679,7 @@ void nano::json_handler::republish () while (block_d != nullptr && hash != source) { hashes.push_back (previous); - source = block_d->source_field ().value_or (block_d->sideband ().details.is_send ? 0 : block_d->link ().as_block_hash ()); + source = block_d->source_field ().value_or (block_d->sideband ().details.is_send ? 0 : block_d->link ().value_or (0).as_block_hash ()); previous = block_d->previous (); block_d = node.ledger.block (transaction, previous); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index fe292f7f7b..608fb375ca 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -260,13 +260,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons // Subtype field else if (block_a->type () == nano::block_type::state) { - if (block_a->link ().is_zero ()) + if (block_a->link ().value ().is_zero ()) { event.add ("subtype", "change"); } else if (is_state_epoch_a) { - debug_assert (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link ())); + debug_assert (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link ().value ())); event.add ("subtype", "epoch"); } else @@ -1252,7 +1252,7 @@ void nano::node::process_confirmed_data (store::transaction const & transaction_ { is_state_send_a = true; } - if (amount_a == 0 && network_params.ledger.epochs.is_epoch_link (state->link ())) + if (amount_a == 0 && network_params.ledger.epochs.is_epoch_link (state->link ().value ())) { is_state_epoch_a = true; } diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index dbd16637ab..eee9297fe8 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1012,13 +1012,13 @@ nano::websocket_server::websocket_server (nano::websocket::config & config_a, na } else if (block_a->type () == nano::block_type::state) { - if (block_a->link ().is_zero ()) + if (block_a->link ().value ().is_zero ()) { subtype = "change"; } else if (is_state_epoch_a) { - debug_assert (amount_a == 0 && ledger.is_epoch_link (block_a->link ())); + debug_assert (amount_a == 0 && ledger.is_epoch_link (block_a->link ().value ())); subtype = "epoch"; } else diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 236165745e..f7a0a45cbf 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -21,7 +21,7 @@ TEST (rpc, receivable) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); ASSERT_EQ (1, blocks_node.size ()); @@ -39,7 +39,7 @@ TEST (rpc, receivable_sorting) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); request.put ("sorting", "true"); // Sorting test auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); @@ -60,7 +60,7 @@ TEST (rpc, receivable_threshold_sufficient) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); request.put ("threshold", "1"); // Threshold test auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); @@ -91,7 +91,7 @@ TEST (rpc, receivable_threshold_insufficient) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); request.put ("threshold", "2"); // Chains are set up with 1 raw transfers therefore all blocks are less than 2 raw. auto response = wait_response (system, rpc_ctx, request, 10s); auto & blocks_node = response.get_child ("blocks"); @@ -108,7 +108,7 @@ TEST (rpc, receivable_source_min_version) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); request.put ("source", "true"); request.put ("min_version", "true"); auto response (wait_response (system, rpc_ctx, request)); @@ -140,7 +140,7 @@ TEST (rpc, receivable_unconfirmed) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().to_account ()); + request.put ("account", block1->link ().value ().to_account ()); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); request.put ("include_only_confirmed", "true"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); @@ -410,14 +410,14 @@ TEST (rpc, accounts_receivable_blocks) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().to_account ()); + entry.put ("", block1->link ().value ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); auto response = wait_response (system, rpc_ctx, request); for (auto & blocks : response.get_child ("blocks")) { std::string account_text{ blocks.first }; - ASSERT_EQ (block1->link ().to_account (), account_text); + ASSERT_EQ (block1->link ().value ().to_account (), account_text); nano::block_hash hash1{ blocks.second.begin ()->second.get ("") }; ASSERT_EQ (block1->hash (), hash1); } @@ -436,7 +436,7 @@ TEST (rpc, accounts_receivable_sorting) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().to_account ()); + entry.put ("", block1->link ().value ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("sorting", "true"); // Sorting test @@ -444,7 +444,7 @@ TEST (rpc, accounts_receivable_sorting) for (auto & blocks : response.get_child ("blocks")) { std::string account_text{ blocks.first }; - ASSERT_EQ (block1->link ().to_account (), account_text); + ASSERT_EQ (block1->link ().value ().to_account (), account_text); nano::block_hash hash1{ blocks.second.begin ()->first }; ASSERT_EQ (block1->hash (), hash1); std::string amount{ blocks.second.begin ()->second.get ("") }; @@ -465,7 +465,7 @@ TEST (rpc, accounts_receivable_threshold) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().to_account ()); + entry.put ("", block1->link ().value ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("threshold", "1"); // Threshold test @@ -474,7 +474,7 @@ TEST (rpc, accounts_receivable_threshold) for (auto & pending : response.get_child ("blocks")) { std::string account_text{ pending.first }; - ASSERT_EQ (block1->link ().to_account (), account_text); + ASSERT_EQ (block1->link ().value ().to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { nano::block_hash hash; @@ -501,7 +501,7 @@ TEST (rpc, accounts_receivable_source) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().to_account ()); + entry.put ("", block1->link ().value ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("source", "true"); @@ -512,7 +512,7 @@ TEST (rpc, accounts_receivable_source) for (auto & pending : response.get_child ("blocks")) { std::string account_text (pending.first); - ASSERT_EQ (block1->link ().to_account (), account_text); + ASSERT_EQ (block1->link ().value ().to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { nano::block_hash hash; @@ -540,7 +540,7 @@ TEST (rpc, accounts_receivable_confirmed) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().to_account ()); + entry.put ("", block1->link ().value ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 16fd731465..b188faae14 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -923,7 +923,7 @@ TEST (rpc, history) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); nano::block_builder builder; auto usend = builder @@ -1007,7 +1007,7 @@ TEST (rpc, account_history) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); nano::block_builder builder; auto usend = builder @@ -1110,7 +1110,7 @@ TEST (rpc, account_history) auto account2 (system.wallet (0)->deterministic_insert ()); auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, account2, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); - auto receive2 (system.wallet (0)->receive_action (send2->hash (), account2, node0->config.receive_minimum.number (), send2->link ().as_account ())); + auto receive2 (system.wallet (0)->receive_action (send2->hash (), account2, node0->config.receive_minimum.number (), send2->link ().value ().as_account ())); // Test filter for send state blocks ASSERT_NE (nullptr, receive2); { @@ -1153,7 +1153,7 @@ TEST (rpc, history_count) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4126,10 +4126,10 @@ TEST (rpc, blocks_info_receive_hash) auto send4 = system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 4); // do 4 receives, mix up the ordering a little - auto recv1 (system.wallet (0)->receive_action (send1->hash (), key1.pub, node->config.receive_minimum.number (), send1->link ().as_account ())); - auto recv4 (system.wallet (0)->receive_action (send4->hash (), key1.pub, node->config.receive_minimum.number (), send4->link ().as_account ())); - auto recv3 (system.wallet (0)->receive_action (send3->hash (), key1.pub, node->config.receive_minimum.number (), send3->link ().as_account ())); - auto recv2 (system.wallet (0)->receive_action (send2->hash (), key1.pub, node->config.receive_minimum.number (), send2->link ().as_account ())); + auto recv1 (system.wallet (0)->receive_action (send1->hash (), key1.pub, node->config.receive_minimum.number (), send1->link ().value ().as_account ())); + auto recv4 (system.wallet (0)->receive_action (send4->hash (), key1.pub, node->config.receive_minimum.number (), send4->link ().value ().as_account ())); + auto recv3 (system.wallet (0)->receive_action (send3->hash (), key1.pub, node->config.receive_minimum.number (), send3->link ().value ().as_account ())); + auto recv2 (system.wallet (0)->receive_action (send2->hash (), key1.pub, node->config.receive_minimum.number (), send2->link ().value ().as_account ())); // function to check that all 4 receive blocks are cemented auto all_blocks_cemented = [node, &key1] () -> bool { @@ -4192,7 +4192,7 @@ TEST (rpc, blocks_info_subtype) system.wallet (0)->insert_adhoc (key.prv); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, nano::Gxrb_ratio)); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), key.pub, nano::Gxrb_ratio, send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), key.pub, nano::Gxrb_ratio, send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, key.pub)); ASSERT_NE (nullptr, change); @@ -5177,7 +5177,7 @@ TEST (rpc, online_reps) auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, new_rep, node1->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); ASSERT_TIMELY (10s, node2->block (send->hash ())); - auto receive (system.wallet (1)->receive_action (send->hash (), new_rep, node1->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (1)->receive_action (send->hash (), new_rep, node1->config.receive_minimum.number (), send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); ASSERT_TIMELY (5s, node2->block (receive->hash ())); auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, new_rep)); @@ -5666,7 +5666,7 @@ TEST (rpc, DISABLED_wallet_history) auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); auto timestamp2 = nano::seconds_since_epoch (); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().value ().as_account ())); ASSERT_NE (nullptr, receive); nano::keypair key; auto timestamp3 = nano::seconds_since_epoch (); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index d35a03d40a..49efbeae5f 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -224,7 +224,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) if (validate_message (block_a.hashables.account, block_a.hash (), block_a.signature)) { // Is epoch block signed correctly - if (validate_message (ledger.epoch_signer (block_a.link ()), block_a.hash (), block_a.signature)) + if (validate_message (ledger.epoch_signer (block_a.link ().value ()), block_a.hash (), block_a.signature)) { result = nano::block_status::bad_signature; } From 9bcb65ca2434ce3bc78f37544e4ffaf2d673a326 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Thu, 7 Mar 2024 17:12:10 +0000 Subject: [PATCH 165/190] Moving ledger::is_send to block::is_send. A specialised variant of is_send for state blocks that do not have sideband was added to dependent_block_visitor so the value can be calculated even if the block does not yet have sideband. --- nano/core_test/ledger.cpp | 38 ++++++++--------- nano/lib/blocks.cpp | 14 +++++++ nano/lib/blocks.hpp | 1 + nano/nano_node/entry.cpp | 2 +- nano/node/active_transactions.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap_ascending/service.cpp | 3 +- nano/node/json_handler.cpp | 4 +- nano/rpc_test/rpc.cpp | 2 +- nano/secure/ledger.cpp | 50 ++++++++--------------- nano/secure/ledger.hpp | 1 - 11 files changed, 57 insertions(+), 62 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 35c44d4faf..55913060fa 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2392,7 +2392,7 @@ TEST (ledger, state_send_receive) ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, send2->sideband ().height); - ASSERT_TRUE (send2->sideband ().details.is_send); + ASSERT_TRUE (send2->is_send ()); ASSERT_FALSE (send2->sideband ().details.is_receive); ASSERT_FALSE (send2->sideband ().details.is_epoch); auto receive1 = builder @@ -2416,7 +2416,7 @@ TEST (ledger, state_send_receive) ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); ASSERT_EQ (3, receive2->sideband ().height); - ASSERT_FALSE (receive2->sideband ().details.is_send); + ASSERT_FALSE (receive2->is_send ()); ASSERT_TRUE (receive2->sideband ().details.is_receive); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -2464,7 +2464,7 @@ TEST (ledger, state_receive) ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (3, receive2->sideband ().height); - ASSERT_FALSE (receive2->sideband ().details.is_send); + ASSERT_FALSE (receive2->is_send ()); ASSERT_TRUE (receive2->sideband ().details.is_receive); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -2498,7 +2498,7 @@ TEST (ledger, state_rep_change) ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); - ASSERT_FALSE (change2->sideband ().details.is_send); + ASSERT_FALSE (change2->is_send ()); ASSERT_FALSE (change2->sideband ().details.is_receive); ASSERT_FALSE (change2->sideband ().details.is_epoch); } @@ -2552,7 +2552,7 @@ TEST (ledger, state_open) ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (ledger.cache.account_count, store.account.count (transaction)); ASSERT_EQ (1, open2->sideband ().height); - ASSERT_FALSE (open2->sideband ().details.is_send); + ASSERT_FALSE (open2->is_send ()); ASSERT_TRUE (open2->sideband ().details.is_receive); ASSERT_FALSE (open2->sideband ().details.is_epoch); } @@ -2978,7 +2978,7 @@ TEST (ledger, state_send_change) ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); - ASSERT_TRUE (send2->sideband ().details.is_send); + ASSERT_TRUE (send2->is_send ()); ASSERT_FALSE (send2->sideband ().details.is_receive); ASSERT_FALSE (send2->sideband ().details.is_epoch); } @@ -3030,7 +3030,7 @@ TEST (ledger, state_receive_change) ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (3, receive2->sideband ().height); - ASSERT_FALSE (receive2->sideband ().details.is_send); + ASSERT_FALSE (receive2->is_send ()); ASSERT_TRUE (receive2->sideband ().details.is_receive); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -3401,7 +3401,7 @@ TEST (ledger, epoch_blocks_v1_general) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); - ASSERT_FALSE (epoch1->sideband ().details.is_send); + ASSERT_FALSE (epoch1->is_send ()); ASSERT_FALSE (epoch1->sideband ().details.is_receive); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); @@ -3428,7 +3428,7 @@ TEST (ledger, epoch_blocks_v1_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); - ASSERT_FALSE (epoch1->sideband ().details.is_send); + ASSERT_FALSE (epoch1->is_send ()); ASSERT_FALSE (epoch1->sideband ().details.is_receive); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); @@ -3452,7 +3452,7 @@ TEST (ledger, epoch_blocks_v1_general) .work (*pool.generate (epoch1->hash ())) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); - ASSERT_TRUE (send1->sideband ().details.is_send); + ASSERT_TRUE (send1->is_send ()); ASSERT_FALSE (send1->sideband ().details.is_receive); ASSERT_FALSE (send1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, send1->sideband ().details.epoch); @@ -3488,7 +3488,7 @@ TEST (ledger, epoch_blocks_v1_general) .work (*pool.generate (destination.pub)) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); - ASSERT_FALSE (epoch4->sideband ().details.is_send); + ASSERT_FALSE (epoch4->is_send ()); ASSERT_FALSE (epoch4->sideband ().details.is_receive); ASSERT_TRUE (epoch4->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch4->sideband ().details.epoch); @@ -3519,7 +3519,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); - ASSERT_FALSE (receive2->sideband ().details.is_send); + ASSERT_FALSE (receive2->is_send ()); ASSERT_TRUE (receive2->sideband ().details.is_receive); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -4295,7 +4295,7 @@ TEST (ledger, unchecked_epoch_invalid) auto epoch2_store = node1.ledger.block (transaction, epoch2->hash ()); ASSERT_NE (nullptr, epoch2_store); ASSERT_EQ (nano::epoch::epoch_0, epoch2_store->sideband ().details.epoch); - ASSERT_TRUE (epoch2_store->sideband ().details.is_send); + ASSERT_TRUE (epoch2_store->is_send ()); ASSERT_FALSE (epoch2_store->sideband ().details.is_epoch); ASSERT_FALSE (epoch2_store->sideband ().details.is_receive); } @@ -4916,7 +4916,7 @@ TEST (ledger, pruning_action) ASSERT_EQ (*receive1, *receive1_stored); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (4, receive1_stored->sideband ().height); - ASSERT_FALSE (receive1_stored->sideband ().details.is_send); + ASSERT_FALSE (receive1_stored->is_send ()); ASSERT_TRUE (receive1_stored->sideband ().details.is_receive); ASSERT_FALSE (receive1_stored->sideband ().details.is_epoch); // Middle block pruning @@ -5547,7 +5547,7 @@ TEST (ledger, is_send_genesis) auto & ledger = ctx.ledger (); auto & store = ctx.store (); auto tx = store.tx_begin_read (); - ASSERT_FALSE (ledger.is_send (tx, *nano::dev::genesis)); + ASSERT_FALSE (nano::dev::genesis->is_send ()); } TEST (ledger, is_send_state) @@ -5556,8 +5556,8 @@ TEST (ledger, is_send_state) auto & ledger = ctx.ledger (); auto & store = ctx.store (); auto tx = store.tx_begin_read (); - ASSERT_TRUE (ledger.is_send (tx, *ctx.blocks ()[0])); - ASSERT_FALSE (ledger.is_send (tx, *ctx.blocks ()[1])); + ASSERT_TRUE (ctx.blocks ()[0]->is_send ()); + ASSERT_FALSE (ctx.blocks ()[1]->is_send ()); } TEST (ledger, is_send_legacy) @@ -5566,8 +5566,8 @@ TEST (ledger, is_send_legacy) auto & ledger = ctx.ledger (); auto & store = ctx.store (); auto tx = store.tx_begin_read (); - ASSERT_TRUE (ledger.is_send (tx, *ctx.blocks ()[0])); - ASSERT_FALSE (ledger.is_send (tx, *ctx.blocks ()[1])); + ASSERT_TRUE (ctx.blocks ()[0]->is_send ()); + ASSERT_FALSE (ctx.blocks ()[1]->is_send ()); } TEST (ledger, head_block) diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 1d1f19e3d2..713196e5ca 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -115,6 +115,20 @@ void nano::block::refresh () } } +bool nano::block::is_send () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::send: + return true; + case nano::block_type::state: + return sideband ().details.is_send; + default: + return false; + } +} + nano::block_hash const & nano::block::hash () const { if (!cached_hash.is_zero ()) diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index b67bf3c91e..2c0c2d1798 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -55,6 +55,7 @@ class block virtual nano::work_version work_version () const; // If there are any changes to the hashables, call this to update the cached hash void refresh (); + bool is_send () const noexcept; public: // Direct access to the block fields or nullopt if the block type does not have the specified field // Returns account field or account from sideband diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index a01d25b1f9..4153f923ef 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1697,7 +1697,7 @@ int main (int argc, char * const * argv) } if (auto state = dynamic_cast (block.get ())) { - if (node->ledger.is_send (transaction, *state)) + if (state->is_send ()) { destination = state->hashables.link.as_account (); } diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 22600bfc6f..d2df96e361 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -165,7 +165,7 @@ void nano::active_transactions::handle_confirmation (nano::store::read_transacti void nano::active_transactions::handle_block_confirmation (nano::store::read_transaction const & transaction, std::shared_ptr const & block, nano::block_hash const & hash, nano::account & account, nano::uint128_t & amount, bool & is_state_send, bool & is_state_epoch, nano::account & pending_account) { - if (block->sideband ().details.is_send) + if (block->is_send ()) { node.receive_confirmed (transaction, hash, block->destination ()); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index d968a312e2..53e6fe06ef 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -340,7 +340,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction /* For send blocks check epoch open unchecked (gap pending). For state blocks check only send subtype and only if block epoch is not last epoch. If epoch is last, then pending entry shouldn't trigger same epoch open block for destination account. */ - if (block->type () == nano::block_type::send || (block->type () == nano::block_type::state && block->sideband ().details.is_send && std::underlying_type_t (block->sideband ().details.epoch) < std::underlying_type_t (nano::epoch::max))) + if (block->type () == nano::block_type::send || (block->type () == nano::block_type::state && block->is_send () && std::underlying_type_t (block->sideband ().details.epoch) < std::underlying_type_t (nano::epoch::max))) { /* block->destination () for legacy send blocks block->link () for state blocks (send subtype) */ diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index a614f0e34b..37f01746a1 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -134,14 +134,13 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, case nano::block_status::progress: { const auto account = block.account (); - const auto is_send = ledger.is_send (tx, block); // If we've inserted any block in to an account, unmark it as blocked accounts.unblock (account); accounts.priority_up (account); accounts.timestamp (account, /* reset timestamp */ true); - if (is_send) + if (block.is_send ()) { auto destination = block.destination (); accounts.unblock (destination, hash); // Unblocking automatically inserts account into priority set diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 8a5e185fc6..4c4934560c 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1223,7 +1223,7 @@ void nano::json_handler::block_confirm () { if (auto state = dynamic_cast (block_l.get ())) { - is_state_send = node.ledger.is_send (transaction, *state); + is_state_send = state->is_send (); is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link ().value ()); } } @@ -3679,7 +3679,7 @@ void nano::json_handler::republish () while (block_d != nullptr && hash != source) { hashes.push_back (previous); - source = block_d->source_field ().value_or (block_d->sideband ().details.is_send ? 0 : block_d->link ().value_or (0).as_block_hash ()); + source = block_d->source_field ().value_or (block_d->is_send () ? 0 : block_d->link ().value_or (0).as_block_hash ()); previous = block_d->previous (); block_d = node.ledger.block (transaction, previous); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index b188faae14..b74fe6eeca 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -4951,7 +4951,7 @@ TEST (rpc, block_create_send_epoch_v2) auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); - ASSERT_TRUE (state_block->sideband ().details.is_send); + ASSERT_TRUE (state_block->is_send ()); ASSERT_FALSE (node->latest (key.pub).is_zero ()); } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 49efbeae5f..836370e33e 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -950,38 +950,6 @@ std::string nano::ledger::block_text (nano::block_hash const & hash_a) return result; } -bool nano::ledger::is_send (store::transaction const & transaction_a, nano::block const & block_a) const -{ - if (block_a.type () != nano::block_type::state) - { - return block_a.type () == nano::block_type::send; - } - nano::block_hash previous = block_a.previous (); - /* - * if block_a does not have a sideband, then is_send() - * requires that the previous block exists in the database. - * This is because it must retrieve the balance of the previous block. - */ - debug_assert (block_a.has_sideband () || previous.is_zero () || block_exists (transaction_a, previous)); - - bool result (false); - if (block_a.has_sideband ()) - { - result = block_a.sideband ().details.is_send; - } - else - { - if (!previous.is_zero ()) - { - if (block_a.balance_field ().value () < balance (transaction_a, previous)) - { - result = true; - } - } - } - return result; -} - nano::account const & nano::ledger::block_destination (store::transaction const & transaction_a, nano::block const & block_a) { nano::send_block const * send_block (dynamic_cast (&block_a)); @@ -990,7 +958,7 @@ nano::account const & nano::ledger::block_destination (store::transaction const { return send_block->hashables.destination; } - else if (state_block != nullptr && is_send (transaction_a, *state_block)) + else if (state_block != nullptr && block_a.is_send ()) { return state_block->hashables.link.as_account (); } @@ -1208,11 +1176,25 @@ class dependent_block_visitor : public nano::block_visitor result[0] = block_a.hashables.previous; result[1] = block_a.hashables.link.as_block_hash (); // ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped - if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a))) + if (ledger.is_epoch_link (block_a.hashables.link) || is_send (transaction, block_a)) { result[1].clear (); } } + // This function is used in place of block->is_send () as it is tolerant to the block not having the sideband information loaded + // This is needed for instance in vote generation on forks which have not yet had sideband information attached + bool is_send (nano::store::transaction const & transaction, nano::state_block const & block) const + { + if (block.previous ().is_zero ()) + { + return false; + } + if (block.has_sideband ()) + { + return block.sideband ().details.is_send; + } + return block.balance_field ().value () < ledger.balance (transaction, block.previous ()); + } nano::ledger const & ledger; nano::store::transaction const & transaction; std::array result; diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 229c86b8d4..5f1b1e49b8 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -56,7 +56,6 @@ class ledger final bool root_exists (store::transaction const &, nano::root const &); std::string block_text (char const *); std::string block_text (nano::block_hash const &); - bool is_send (store::transaction const &, nano::block const &) const; nano::account const & block_destination (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; From a60a16b338afd2ed48337ff5c665910f28580b40 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 8 Mar 2024 00:04:10 +0000 Subject: [PATCH 166/190] Creating block::is_receive function to determine if a block is a receive/open/state block that's a receive --- nano/core_test/ledger.cpp | 28 ++++++++++++++-------------- nano/lib/blocks.cpp | 15 +++++++++++++++ nano/lib/blocks.hpp | 1 + nano/node/json_handler.cpp | 2 +- nano/rpc_test/rpc.cpp | 6 +++--- nano/secure/ledger.cpp | 2 +- 6 files changed, 35 insertions(+), 19 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 55913060fa..a08eb2422c 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2393,7 +2393,7 @@ TEST (ledger, state_send_receive) ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->is_send ()); - ASSERT_FALSE (send2->sideband ().details.is_receive); + ASSERT_FALSE (send2->is_receive ()); ASSERT_FALSE (send2->sideband ().details.is_epoch); auto receive1 = builder .state () @@ -2417,7 +2417,7 @@ TEST (ledger, state_send_receive) ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->is_send ()); - ASSERT_TRUE (receive2->sideband ().details.is_receive); + ASSERT_TRUE (receive2->is_receive ()); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -2465,7 +2465,7 @@ TEST (ledger, state_receive) ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->is_send ()); - ASSERT_TRUE (receive2->sideband ().details.is_receive); + ASSERT_TRUE (receive2->is_receive ()); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -2499,7 +2499,7 @@ TEST (ledger, state_rep_change) ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); ASSERT_FALSE (change2->is_send ()); - ASSERT_FALSE (change2->sideband ().details.is_receive); + ASSERT_FALSE (change2->is_receive ()); ASSERT_FALSE (change2->sideband ().details.is_epoch); } @@ -2553,7 +2553,7 @@ TEST (ledger, state_open) ASSERT_EQ (ledger.cache.account_count, store.account.count (transaction)); ASSERT_EQ (1, open2->sideband ().height); ASSERT_FALSE (open2->is_send ()); - ASSERT_TRUE (open2->sideband ().details.is_receive); + ASSERT_TRUE (open2->is_receive ()); ASSERT_FALSE (open2->sideband ().details.is_epoch); } @@ -2979,7 +2979,7 @@ TEST (ledger, state_send_change) ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->is_send ()); - ASSERT_FALSE (send2->sideband ().details.is_receive); + ASSERT_FALSE (send2->is_receive ()); ASSERT_FALSE (send2->sideband ().details.is_epoch); } @@ -3031,7 +3031,7 @@ TEST (ledger, state_receive_change) ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->is_send ()); - ASSERT_TRUE (receive2->sideband ().details.is_receive); + ASSERT_TRUE (receive2->is_receive ()); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -3402,7 +3402,7 @@ TEST (ledger, epoch_blocks_v1_general) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_FALSE (epoch1->is_send ()); - ASSERT_FALSE (epoch1->sideband ().details.is_receive); + ASSERT_FALSE (epoch1->is_receive ()); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks @@ -3429,7 +3429,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); ASSERT_FALSE (epoch1->is_send ()); - ASSERT_FALSE (epoch1->sideband ().details.is_receive); + ASSERT_FALSE (epoch1->is_receive ()); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1->sideband ().source_epoch); // Not used for epoch blocks @@ -3453,7 +3453,7 @@ TEST (ledger, epoch_blocks_v1_general) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (send1->is_send ()); - ASSERT_FALSE (send1->sideband ().details.is_receive); + ASSERT_FALSE (send1->is_receive ()); ASSERT_FALSE (send1->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, send1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1->sideband ().source_epoch); // Not used for send blocks @@ -3489,7 +3489,7 @@ TEST (ledger, epoch_blocks_v1_general) .build (); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_FALSE (epoch4->is_send ()); - ASSERT_FALSE (epoch4->sideband ().details.is_receive); + ASSERT_FALSE (epoch4->is_receive ()); ASSERT_TRUE (epoch4->sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks @@ -3520,7 +3520,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); ASSERT_FALSE (receive2->is_send ()); - ASSERT_TRUE (receive2->sideband ().details.is_receive); + ASSERT_TRUE (receive2->is_receive ()); ASSERT_FALSE (receive2->sideband ().details.is_epoch); } @@ -4297,7 +4297,7 @@ TEST (ledger, unchecked_epoch_invalid) ASSERT_EQ (nano::epoch::epoch_0, epoch2_store->sideband ().details.epoch); ASSERT_TRUE (epoch2_store->is_send ()); ASSERT_FALSE (epoch2_store->sideband ().details.is_epoch); - ASSERT_FALSE (epoch2_store->sideband ().details.is_receive); + ASSERT_FALSE (epoch2_store->is_receive ()); } } @@ -4917,7 +4917,7 @@ TEST (ledger, pruning_action) ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis_key.pub, send1->hash ()))); ASSERT_EQ (4, receive1_stored->sideband ().height); ASSERT_FALSE (receive1_stored->is_send ()); - ASSERT_TRUE (receive1_stored->sideband ().details.is_receive); + ASSERT_TRUE (receive1_stored->is_receive ()); ASSERT_FALSE (receive1_stored->sideband ().details.is_epoch); // Middle block pruning ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 713196e5ca..2a644a615e 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -129,6 +129,21 @@ bool nano::block::is_send () const noexcept } } +bool nano::block::is_receive () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::receive: + case nano::block_type::open: + return true; + case nano::block_type::state: + return sideband ().details.is_receive; + default: + return false; + } +} + nano::block_hash const & nano::block::hash () const { if (!cached_hash.is_zero ()) diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 2c0c2d1798..b93582c55c 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -56,6 +56,7 @@ class block // If there are any changes to the hashables, call this to update the cached hash void refresh (); bool is_send () const noexcept; + bool is_receive () const noexcept; public: // Direct access to the block fields or nullopt if the block type does not have the specified field // Returns account field or account from sideband diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 4c4934560c..894234ce72 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1383,7 +1383,7 @@ void nano::json_handler::blocks_info () } if (source) { - if (!block->sideband ().details.is_receive || !node.ledger.block_exists (transaction, block->source ())) + if (!block->is_receive () || !node.ledger.block_exists (transaction, block->source ())) { entry.put ("source_account", "0"); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index b74fe6eeca..bfda4364af 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -4769,7 +4769,7 @@ TEST (rpc, block_create_state_open) auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); - ASSERT_TRUE (state_block->sideband ().details.is_receive); + ASSERT_TRUE (state_block->is_receive ()); ASSERT_FALSE (node->latest (key.pub).is_zero ()); } @@ -4848,7 +4848,7 @@ TEST (rpc, block_create_open_epoch_v2) auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); - ASSERT_TRUE (state_block->sideband ().details.is_receive); + ASSERT_TRUE (state_block->is_receive ()); ASSERT_FALSE (node->latest (key.pub).is_zero ()); } @@ -4900,7 +4900,7 @@ TEST (rpc, block_create_receive_epoch_v2) auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); - ASSERT_TRUE (state_block->sideband ().details.is_receive); + ASSERT_TRUE (state_block->is_receive ()); ASSERT_FALSE (node->latest (key.pub).is_zero ()); } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 836370e33e..ce6ceb105e 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1227,7 +1227,7 @@ std::shared_ptr nano::ledger::find_receive_block_by_send_hash (stor // walk down the chain until the source field of a receive block matches the send block hash while (possible_receive_block != nullptr) { - if (possible_receive_block->sideband ().details.is_receive && send_block_hash == possible_receive_block->source ()) + if (possible_receive_block->is_receive () && send_block_hash == possible_receive_block->source ()) { // we have a match result = possible_receive_block; From dece1bcb10eb084908b682a5f299291197199e51 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 8 Mar 2024 00:32:17 +0000 Subject: [PATCH 167/190] Create block::is_change function which determines if a block is a change block or a state block with a zero link field. --- nano/lib/blocks.cpp | 18 ++++++++++++++++++ nano/lib/blocks.hpp | 1 + nano/nano_node/entry.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 2 +- nano/node/node.cpp | 2 +- nano/node/websocket.cpp | 2 +- 6 files changed, 23 insertions(+), 4 deletions(-) diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 2a644a615e..3caf2f51b0 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -144,6 +144,24 @@ bool nano::block::is_receive () const noexcept } } +bool nano::block::is_change () const noexcept +{ + release_assert (has_sideband ()); + switch (type ()) + { + case nano::block_type::change: + return true; + case nano::block_type::state: + if (link ().value ().is_zero ()) + { + return true; + } + return false; + default: + return false; + } +} + nano::block_hash const & nano::block::hash () const { if (!cached_hash.is_zero ()) diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index b93582c55c..f1a7b56c8d 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -57,6 +57,7 @@ class block void refresh (); bool is_send () const noexcept; bool is_receive () const noexcept; + bool is_change () const noexcept; public: // Direct access to the block fields or nullopt if the block type does not have the specified field // Returns account field or account from sideband diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 4153f923ef..4ce7a30028 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1529,7 +1529,7 @@ int main (int argc, char * const * argv) } else { - if (block->link ().value ().is_zero ()) + if (block->is_change ()) { // State change block_details_error = sideband.details.is_send || sideband.details.is_receive || sideband.details.is_epoch; diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index de252a0792..a36a0d2d49 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -20,7 +20,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano { block->subtype = nanoapi::BlockSubType::BlockSubType_send; } - else if (block_a.link ().value ().is_zero ()) + else if (block_a.is_change ()) { block->subtype = nanoapi::BlockSubType::BlockSubType_change; } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 608fb375ca..8b1a3e86c4 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -260,7 +260,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons // Subtype field else if (block_a->type () == nano::block_type::state) { - if (block_a->link ().value ().is_zero ()) + if (block_a->is_change ()) { event.add ("subtype", "change"); } diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index eee9297fe8..f9de5a6c67 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1012,7 +1012,7 @@ nano::websocket_server::websocket_server (nano::websocket::config & config_a, na } else if (block_a->type () == nano::block_type::state) { - if (block_a->link ().value ().is_zero ()) + if (block_a->is_change ()) { subtype = "change"; } From 17e502d543a96dd85acb8b387cd1201ea57b68e3 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 8 Mar 2024 09:46:25 +0000 Subject: [PATCH 168/190] Renaming block::link to block::link_field. Usages that converted this number to an account number are replaced with calls to block::destination (). Usages that converted this number to a block_hash are replaced with calls to block::source, and usages that check this number for being an epoch directly access the link field. --- nano/core_test/block.cpp | 10 +++---- nano/core_test/wallet.cpp | 12 ++++----- nano/core_test/wallets.cpp | 2 +- nano/lib/blocks.cpp | 10 +++---- nano/lib/blocks.hpp | 4 +-- nano/nano_node/entry.cpp | 8 +++--- nano/node/blockprocessor.cpp | 4 +-- nano/node/bootstrap_ascending/service.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 5 ++-- nano/node/confirmation_height_unbounded.cpp | 5 ++-- nano/node/ipc/flatbuffers_util.cpp | 4 +-- nano/node/json_handler.cpp | 12 ++++----- nano/node/node.cpp | 4 +-- nano/node/websocket.cpp | 2 +- nano/rpc_test/receivable.cpp | 30 ++++++++++----------- nano/rpc_test/rpc.cpp | 22 +++++++-------- nano/secure/ledger.cpp | 2 +- 17 files changed, 68 insertions(+), 70 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index cab5e34a2d..f5dd614b3d 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -659,7 +659,7 @@ TEST (block_builder, state) ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F"); ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); - ASSERT_EQ (block->link ().value ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); + ASSERT_EQ (block->link_field ().value ().to_string (), "E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86"); } TEST (block_builder, state_missing_rep) @@ -732,7 +732,7 @@ TEST (block_builder, open) ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); ASSERT_EQ (block->source_field ().value ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"); ASSERT_FALSE (block->destination_field ()); - ASSERT_FALSE (block->link ()); + ASSERT_FALSE (block->link_field ()); } TEST (block_builder, open_equality) @@ -771,7 +771,7 @@ TEST (block_builder, change) ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077"); ASSERT_FALSE (block->source_field ()); ASSERT_FALSE (block->destination_field ()); - ASSERT_FALSE (block->link ()); + ASSERT_FALSE (block->link_field ()); } TEST (block_builder, change_equality) @@ -810,7 +810,7 @@ TEST (block_builder, send) ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_FALSE (block->source_field ()); ASSERT_EQ (block->destination_field ().value ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); - ASSERT_FALSE (block->link ()); + ASSERT_FALSE (block->link_field ()); } TEST (block_builder, send_equality) @@ -872,5 +872,5 @@ TEST (block_builder, receive) ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722"); ASSERT_EQ (block->source_field ().value ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135"); ASSERT_FALSE (block->destination_field ()); - ASSERT_FALSE (block->link ()); + ASSERT_FALSE (block->link_field ()); } diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index c1a56fc5d5..0250f291d9 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1001,7 +1001,7 @@ TEST (wallet, epoch_2_validation) ASSERT_EQ (nano::epoch::epoch_2, send->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send->sideband ().source_epoch); // Not used for send state blocks - auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().value ().as_account (), 1); + auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->destination (), 1); ASSERT_NE (nullptr, receive); if (nano::dev::network_params.work.difficulty (*receive) < node.network_params.work.base) { @@ -1043,7 +1043,7 @@ TEST (wallet, epoch_2_receive_propagation) auto amount = node.config.receive_minimum.number (); auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send1); - ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->link ().value ().as_account (), 1)); + ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->destination (), 1)); // Upgrade the genesis account to epoch 2 auto epoch2 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_2); @@ -1053,7 +1053,7 @@ TEST (wallet, epoch_2_receive_propagation) auto send2 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send2); - auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().value ().as_account (), 1); + auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->destination (), 1); ASSERT_NE (nullptr, receive2); if (nano::dev::network_params.work.difficulty (*receive2) < node.network_params.work.base) { @@ -1106,7 +1106,7 @@ TEST (wallet, epoch_2_receive_unopened) wallet.insert_adhoc (key.prv, false); - auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->link ().value ().as_account (), 1); + auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->destination (), 1); ASSERT_NE (nullptr, receive1); if (nano::dev::network_params.work.difficulty (*receive1) < node.network_params.work.base) { @@ -1190,7 +1190,7 @@ TEST (wallet, search_receivable) auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); - ASSERT_EQ (send->hash (), receive->link ().value ().as_block_hash ()); + ASSERT_EQ (send->hash (), receive->source ()); } TEST (wallet, receive_pruned) @@ -1228,7 +1228,7 @@ TEST (wallet, receive_pruned) wallet2.insert_adhoc (key.prv, false); - auto open1 = wallet2.receive_action (send1->hash (), key.pub, amount, send1->link ().value ().as_account (), 1); + auto open1 = wallet2.receive_action (send1->hash (), key.pub, amount, send1->destination (), 1); ASSERT_NE (nullptr, open1); ASSERT_EQ (amount, node2.ledger.balance (node2.store.tx_begin_read (), open1->hash ())); ASSERT_TIMELY_EQ (5s, node2.ledger.cache.cemented_count, 4); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index c596cad9c5..606fa18f4f 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -254,6 +254,6 @@ TEST (wallets, search_receivable) auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); - ASSERT_EQ (send->hash (), receive->link ().value ().as_block_hash ()); + ASSERT_EQ (send->hash (), receive->source ()); } } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 3caf2f51b0..8be4273a69 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -152,7 +152,7 @@ bool nano::block::is_change () const noexcept case nano::block_type::change: return true; case nano::block_type::state: - if (link ().value ().is_zero ()) + if (link_field ().value ().is_zero ()) { return true; } @@ -224,7 +224,7 @@ std::optional nano::block::destination_field () const return std::nullopt; } -std::optional nano::block::link () const +std::optional nano::block::link_field () const { return std::nullopt; } @@ -272,7 +272,7 @@ nano::account nano::block::destination () const noexcept return destination_field ().value (); case nano::block_type::state: release_assert (sideband ().details.is_send); - return link ().value ().as_account (); + return link_field ().value ().as_account (); default: release_assert (false); } @@ -288,7 +288,7 @@ nano::block_hash nano::block::source () const noexcept return source_field ().value (); case nano::block_type::state: release_assert (sideband ().details.is_receive); - return link ().value ().as_block_hash (); + return link_field ().value ().as_block_hash (); default: release_assert (false); } @@ -1470,7 +1470,7 @@ nano::root const & nano::state_block::root () const } } -std::optional nano::state_block::link () const +std::optional nano::state_block::link_field () const { return hashables.link; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index f1a7b56c8d..eb6bc4a07c 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -73,7 +73,7 @@ class block // Destination account for send blocks virtual std::optional destination_field () const; // Link field for state blocks - virtual std::optional link () const; + virtual std::optional link_field () const; // Returns the source block hash for open/receive/state blocks that are receives nano::block_hash source () const noexcept; // Source block for open/receive blocks @@ -369,7 +369,7 @@ class state_block : public nano::block public: // State block fields std::optional account_field () const override; std::optional balance_field () const override; - std::optional link () const override; + std::optional link_field () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 4ce7a30028..31105b7ac7 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1501,7 +1501,7 @@ int main (int argc, char * const * argv) { if ((state_block.hashables.balance == prev_balance && !error_or_pruned) || (node->ledger.pruning && error_or_pruned && block->sideband ().details.is_epoch)) { - invalid = validate_message (node->ledger.epoch_signer (block->link ().value ()), hash, block->block_signature ()); + invalid = validate_message (node->ledger.epoch_signer (block->link_field ().value ()), hash, block->block_signature ()); } } } @@ -1534,7 +1534,7 @@ int main (int argc, char * const * argv) // State change block_details_error = sideband.details.is_send || sideband.details.is_receive || sideband.details.is_epoch; } - else if (block->balance () == prev_balance.value () && node->ledger.is_epoch_link (block->link ().value ())) + else if (block->balance () == prev_balance.value () && node->ledger.is_epoch_link (block->link_field ().value ())) { // State epoch block_details_error = !sideband.details.is_epoch || sideband.details.is_send || sideband.details.is_receive; @@ -1543,7 +1543,7 @@ int main (int argc, char * const * argv) { // State receive block_details_error = !sideband.details.is_receive || sideband.details.is_send || sideband.details.is_epoch; - block_details_error |= !node->ledger.block_or_pruned_exists (transaction, block->link ().value ().as_block_hash ()); + block_details_error |= !node->ledger.block_or_pruned_exists (transaction, block->source ()); } } } @@ -1809,7 +1809,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("%1% blocks retrieved") % count) << std::endl; } node.node->block_processor.add (block); - if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link ().value ())) + if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link_field ().value ())) { // Epoch open blocks can be rejected without processed pending blocks to account, push it later again epoch_open_blocks.push_back (block); diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 53e6fe06ef..92efa88e28 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -356,8 +356,8 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } case nano::block_status::gap_source: { - release_assert (block->source_field () || block->link ()); - node.unchecked.put (block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()), block); + release_assert (block->source_field () || block->link_field ()); + node.unchecked.put (block->source_field ().value_or (block->link_field ().value_or (0).as_block_hash ()), block); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index 37f01746a1..e75a26c247 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -151,7 +151,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, case nano::block_status::gap_source: { const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value (); - const auto source = block.source_field ().value_or (block.link ().value_or (0).as_block_hash ()); + const auto source = block.source_field ().value_or (block.link_field ().value_or (0).as_block_hash ()); // Mark account as blocked because it is missing the source block accounts.block (account, source); diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 459b835abb..dfb7dea6d7 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -253,14 +253,13 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const & // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; auto block = ledger.block (transaction_a, hash); - auto source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) + if (block->is_receive () && ledger.block_exists (transaction_a, block->source ())) { hit_receive = true; reached_target = true; auto const & sideband (block->sideband ()); auto next = !sideband.successor.is_zero () && sideband.successor != top_level_hash_a ? boost::optional (sideband.successor) : boost::none; - receive_source_pairs_a.push_back ({ receive_chain_details{ account_a, sideband.height, hash, top_level_hash_a, next, bottom_height_a, bottom_hash_a }, source }); + receive_source_pairs_a.push_back ({ receive_chain_details{ account_a, sideband.height, hash, top_level_hash_a, next, bottom_height_a, bottom_hash_a }, block->source () }); // Store a checkpoint every max_items so that we can always traverse a long number of accounts to genesis if (receive_source_pairs_a.size () % max_items == 0) { diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 807743b76b..20e7101c13 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -212,8 +212,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source if (block) { - auto source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.block_exists (transaction_a, source)) + if (block->is_receive () && ledger.block_exists (transaction_a, block->source ())) { if (!hit_receive && !block_callback_data_a.empty ()) { @@ -228,7 +227,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source hit_receive = true; auto block_height = confirmation_height_a + num_to_confirm; - receive_source_pairs_a.emplace_back (std::make_shared (account_a, hash, block_height, 1, std::vector{ hash }), source); + receive_source_pairs_a.emplace_back (std::make_shared (account_a, hash, block_height, 1, std::vector{ hash }), block->source ()); } else if (is_original_block) { diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index a36a0d2d49..cd95d848f7 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -11,8 +11,8 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); block->balance = block_a.balance ().to_string_dec (); - block->link = block_a.link ().value ().to_string (); - block->link_as_account = block_a.link ().value ().to_account (); + block->link = block_a.link_field ().value ().to_string (); + block->link_as_account = block_a.link_field ().value ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 894234ce72..386eb7c487 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -411,8 +411,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) { details.epoch = block_previous->sideband ().details.epoch; } - auto link = block_a.link (); - if (link && !details.is_send) + auto link = block_a.link_field (); + if (link && !link.value ().is_zero () && !details.is_send) { auto block_link = node.ledger.block (transaction, link.value ().as_block_hash ()); auto account = block_a.account_field ().value (); // Link is non-zero therefore it's a state block and has an account field; @@ -1224,7 +1224,7 @@ void nano::json_handler::block_confirm () if (auto state = dynamic_cast (block_l.get ())) { is_state_send = state->is_send (); - is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link ().value ()); + is_state_epoch = amount.value () == 0 && node.ledger.is_epoch_link (state->link_field ().value ()); } } node.observers.blocks.notify (status, {}, account, amount ? amount.value () : 0, is_state_send, is_state_epoch); @@ -2522,7 +2522,7 @@ class history_visitor : public nano::block_visitor if (raw && accounts_filter.empty ()) { tree.put ("subtype", "epoch"); - tree.put ("account", handler.node.ledger.epoch_signer (block_a.link ().value ()).to_account ()); + tree.put ("account", handler.node.ledger.epoch_signer (block_a.link_field ().value ()).to_account ()); } } else @@ -3641,7 +3641,7 @@ void nano::json_handler::republish () block = node.ledger.block (transaction, hash); if (sources != 0) // Republish source chain { - nano::block_hash source = block->source_field ().value_or (block->link ().value_or (0).as_block_hash ()); + nano::block_hash source = block->source_field ().value_or (block->link_field ().value_or (0).as_block_hash ()); auto block_a = node.ledger.block (transaction, source); std::vector hashes; while (block_a != nullptr && hashes.size () < sources) @@ -3679,7 +3679,7 @@ void nano::json_handler::republish () while (block_d != nullptr && hash != source) { hashes.push_back (previous); - source = block_d->source_field ().value_or (block_d->is_send () ? 0 : block_d->link ().value_or (0).as_block_hash ()); + source = block_d->source_field ().value_or (block_d->is_send () ? 0 : block_d->link_field ().value_or (0).as_block_hash ()); previous = block_d->previous (); block_d = node.ledger.block (transaction, previous); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 8b1a3e86c4..e9fa0e2d62 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -266,7 +266,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons } else if (is_state_epoch_a) { - debug_assert (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link ().value ())); + debug_assert (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link_field ().value ())); event.add ("subtype", "epoch"); } else @@ -1252,7 +1252,7 @@ void nano::node::process_confirmed_data (store::transaction const & transaction_ { is_state_send_a = true; } - if (amount_a == 0 && network_params.ledger.epochs.is_epoch_link (state->link ().value ())) + if (amount_a == 0 && network_params.ledger.epochs.is_epoch_link (state->link_field ().value ())) { is_state_epoch_a = true; } diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index f9de5a6c67..e33d1c8898 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1018,7 +1018,7 @@ nano::websocket_server::websocket_server (nano::websocket::config & config_a, na } else if (is_state_epoch_a) { - debug_assert (amount_a == 0 && ledger.is_epoch_link (block_a->link ().value ())); + debug_assert (amount_a == 0 && ledger.is_epoch_link (block_a->link_field ().value ())); subtype = "epoch"; } else diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index f7a0a45cbf..d2659aac1d 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -21,7 +21,7 @@ TEST (rpc, receivable) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); ASSERT_EQ (1, blocks_node.size ()); @@ -39,7 +39,7 @@ TEST (rpc, receivable_sorting) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); request.put ("sorting", "true"); // Sorting test auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); @@ -60,7 +60,7 @@ TEST (rpc, receivable_threshold_sufficient) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); request.put ("threshold", "1"); // Threshold test auto response = wait_response (system, rpc_ctx, request); auto & blocks_node = response.get_child ("blocks"); @@ -91,7 +91,7 @@ TEST (rpc, receivable_threshold_insufficient) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); request.put ("threshold", "2"); // Chains are set up with 1 raw transfers therefore all blocks are less than 2 raw. auto response = wait_response (system, rpc_ctx, request, 10s); auto & blocks_node = response.get_child ("blocks"); @@ -108,7 +108,7 @@ TEST (rpc, receivable_source_min_version) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); request.put ("source", "true"); request.put ("min_version", "true"); auto response (wait_response (system, rpc_ctx, request)); @@ -140,7 +140,7 @@ TEST (rpc, receivable_unconfirmed) auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receivable"); - request.put ("account", block1->link ().value ().to_account ()); + request.put ("account", block1->destination ().to_account ()); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); request.put ("include_only_confirmed", "true"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); @@ -410,14 +410,14 @@ TEST (rpc, accounts_receivable_blocks) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().value ().to_account ()); + entry.put ("", block1->destination ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); auto response = wait_response (system, rpc_ctx, request); for (auto & blocks : response.get_child ("blocks")) { std::string account_text{ blocks.first }; - ASSERT_EQ (block1->link ().value ().to_account (), account_text); + ASSERT_EQ (block1->destination ().to_account (), account_text); nano::block_hash hash1{ blocks.second.begin ()->second.get ("") }; ASSERT_EQ (block1->hash (), hash1); } @@ -436,7 +436,7 @@ TEST (rpc, accounts_receivable_sorting) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().value ().to_account ()); + entry.put ("", block1->destination ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("sorting", "true"); // Sorting test @@ -444,7 +444,7 @@ TEST (rpc, accounts_receivable_sorting) for (auto & blocks : response.get_child ("blocks")) { std::string account_text{ blocks.first }; - ASSERT_EQ (block1->link ().value ().to_account (), account_text); + ASSERT_EQ (block1->destination ().to_account (), account_text); nano::block_hash hash1{ blocks.second.begin ()->first }; ASSERT_EQ (block1->hash (), hash1); std::string amount{ blocks.second.begin ()->second.get ("") }; @@ -465,7 +465,7 @@ TEST (rpc, accounts_receivable_threshold) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().value ().to_account ()); + entry.put ("", block1->destination ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("threshold", "1"); // Threshold test @@ -474,7 +474,7 @@ TEST (rpc, accounts_receivable_threshold) for (auto & pending : response.get_child ("blocks")) { std::string account_text{ pending.first }; - ASSERT_EQ (block1->link ().value ().to_account (), account_text); + ASSERT_EQ (block1->destination ().to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { nano::block_hash hash; @@ -501,7 +501,7 @@ TEST (rpc, accounts_receivable_source) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().value ().to_account ()); + entry.put ("", block1->destination ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); request.put ("source", "true"); @@ -512,7 +512,7 @@ TEST (rpc, accounts_receivable_source) for (auto & pending : response.get_child ("blocks")) { std::string account_text (pending.first); - ASSERT_EQ (block1->link ().value ().to_account (), account_text); + ASSERT_EQ (block1->destination ().to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { nano::block_hash hash; @@ -540,7 +540,7 @@ TEST (rpc, accounts_receivable_confirmed) request.put ("action", "accounts_receivable"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", block1->link ().value ().to_account ()); + entry.put ("", block1->destination ().to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index bfda4364af..5006752685 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -923,7 +923,7 @@ TEST (rpc, history) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().value ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->destination ())); ASSERT_NE (nullptr, receive); nano::block_builder builder; auto usend = builder @@ -1007,7 +1007,7 @@ TEST (rpc, account_history) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().value ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->destination ())); ASSERT_NE (nullptr, receive); nano::block_builder builder; auto usend = builder @@ -1110,7 +1110,7 @@ TEST (rpc, account_history) auto account2 (system.wallet (0)->deterministic_insert ()); auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, account2, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); - auto receive2 (system.wallet (0)->receive_action (send2->hash (), account2, node0->config.receive_minimum.number (), send2->link ().value ().as_account ())); + auto receive2 (system.wallet (0)->receive_action (send2->hash (), account2, node0->config.receive_minimum.number (), send2->destination ())); // Test filter for send state blocks ASSERT_NE (nullptr, receive2); { @@ -1153,7 +1153,7 @@ TEST (rpc, history_count) ASSERT_NE (nullptr, change); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().value ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->destination ())); ASSERT_NE (nullptr, receive); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4126,10 +4126,10 @@ TEST (rpc, blocks_info_receive_hash) auto send4 = system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 4); // do 4 receives, mix up the ordering a little - auto recv1 (system.wallet (0)->receive_action (send1->hash (), key1.pub, node->config.receive_minimum.number (), send1->link ().value ().as_account ())); - auto recv4 (system.wallet (0)->receive_action (send4->hash (), key1.pub, node->config.receive_minimum.number (), send4->link ().value ().as_account ())); - auto recv3 (system.wallet (0)->receive_action (send3->hash (), key1.pub, node->config.receive_minimum.number (), send3->link ().value ().as_account ())); - auto recv2 (system.wallet (0)->receive_action (send2->hash (), key1.pub, node->config.receive_minimum.number (), send2->link ().value ().as_account ())); + auto recv1 (system.wallet (0)->receive_action (send1->hash (), key1.pub, node->config.receive_minimum.number (), send1->destination ())); + auto recv4 (system.wallet (0)->receive_action (send4->hash (), key1.pub, node->config.receive_minimum.number (), send4->destination ())); + auto recv3 (system.wallet (0)->receive_action (send3->hash (), key1.pub, node->config.receive_minimum.number (), send3->destination ())); + auto recv2 (system.wallet (0)->receive_action (send2->hash (), key1.pub, node->config.receive_minimum.number (), send2->destination ())); // function to check that all 4 receive blocks are cemented auto all_blocks_cemented = [node, &key1] () -> bool { @@ -4192,7 +4192,7 @@ TEST (rpc, blocks_info_subtype) system.wallet (0)->insert_adhoc (key.prv); auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, nano::Gxrb_ratio)); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), key.pub, nano::Gxrb_ratio, send->link ().value ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), key.pub, nano::Gxrb_ratio, send->destination ())); ASSERT_NE (nullptr, receive); auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, key.pub)); ASSERT_NE (nullptr, change); @@ -5177,7 +5177,7 @@ TEST (rpc, online_reps) auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, new_rep, node1->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); ASSERT_TIMELY (10s, node2->block (send->hash ())); - auto receive (system.wallet (1)->receive_action (send->hash (), new_rep, node1->config.receive_minimum.number (), send->link ().value ().as_account ())); + auto receive (system.wallet (1)->receive_action (send->hash (), new_rep, node1->config.receive_minimum.number (), send->destination ())); ASSERT_NE (nullptr, receive); ASSERT_TIMELY (5s, node2->block (receive->hash ())); auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, new_rep)); @@ -5666,7 +5666,7 @@ TEST (rpc, DISABLED_wallet_history) auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); auto timestamp2 = nano::seconds_since_epoch (); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().value ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->destination ())); ASSERT_NE (nullptr, receive); nano::keypair key; auto timestamp3 = nano::seconds_since_epoch (); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index ce6ceb105e..02447c33fd 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -224,7 +224,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) if (validate_message (block_a.hashables.account, block_a.hash (), block_a.signature)) { // Is epoch block signed correctly - if (validate_message (ledger.epoch_signer (block_a.link ().value ()), block_a.hash (), block_a.signature)) + if (validate_message (ledger.epoch_signer (block_a.link_field ().value ()), block_a.hash (), block_a.signature)) { result = nano::block_status::bad_signature; } From e75fb68b05de3cee9cc7156be46383c1bb79e8c4 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 8 Mar 2024 10:17:43 +0000 Subject: [PATCH 169/190] Change block::representative to return an std::optional if the block actually contains the field. --- nano/lib/blocks.cpp | 17 ++++++++--------- nano/lib/blocks.hpp | 11 +++++++---- nano/nano_node/entry.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 6 +++--- nano/node/json_handler.cpp | 4 ++-- nano/rpc_test/rpc.cpp | 4 ++-- nano/secure/ledger.cpp | 28 ++++++++++++++-------------- 7 files changed, 37 insertions(+), 35 deletions(-) diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 8be4273a69..c174a6d99e 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -208,10 +208,9 @@ bool nano::block::has_sideband () const return sideband_m.is_initialized (); } -nano::account const & nano::block::representative () const +std::optional nano::block::representative_field () const { - static nano::account representative{}; - return representative; + return std::nullopt; } std::optional nano::block::source_field () const @@ -796,7 +795,7 @@ void nano::open_block::serialize_json (boost::property_tree::ptree & tree) const { tree.put ("type", "open"); tree.put ("source", hashables.source.to_string ()); - tree.put ("representative", representative ().to_account ()); + tree.put ("representative", hashables.representative.to_account ()); tree.put ("account", hashables.account.to_account ()); std::string signature_l; signature.encode_hex (signature_l); @@ -880,7 +879,7 @@ nano::root const & nano::open_block::root () const return hashables.account; } -nano::account const & nano::open_block::representative () const +std::optional nano::open_block::representative_field () const { return hashables.representative; } @@ -1060,7 +1059,7 @@ void nano::change_block::serialize_json (boost::property_tree::ptree & tree) con { tree.put ("type", "change"); tree.put ("previous", hashables.previous.to_string ()); - tree.put ("representative", representative ().to_account ()); + tree.put ("representative", hashables.representative.to_account ()); tree.put ("work", nano::to_string_hex (work)); std::string signature_l; signature.encode_hex (signature_l); @@ -1146,7 +1145,7 @@ nano::root const & nano::change_block::root () const return hashables.previous; } -nano::account const & nano::change_block::representative () const +std::optional nano::change_block::representative_field () const { return hashables.representative; } @@ -1372,7 +1371,7 @@ void nano::state_block::serialize_json (boost::property_tree::ptree & tree) cons tree.put ("type", "state"); tree.put ("account", hashables.account.to_account ()); tree.put ("previous", hashables.previous.to_string ()); - tree.put ("representative", representative ().to_account ()); + tree.put ("representative", hashables.representative.to_account ()); tree.put ("balance", hashables.balance.to_string_dec ()); tree.put ("link", hashables.link.to_string ()); tree.put ("link_as_account", hashables.link.to_account ()); @@ -1475,7 +1474,7 @@ std::optional nano::state_block::link_field () const return hashables.link; } -nano::account const & nano::state_block::representative () const +std::optional nano::state_block::representative_field () const { return hashables.representative; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index eb6bc4a07c..ad860a1bc4 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -39,7 +39,6 @@ class block virtual nano::root const & root () const = 0; // Qualified root value based on previous() and root() virtual nano::qualified_root qualified_root () const; - virtual nano::account const & representative () const; virtual void serialize (nano::stream &) const = 0; virtual void serialize_json (std::string &, bool = false) const = 0; virtual void serialize_json (boost::property_tree::ptree &) const = 0; @@ -74,6 +73,8 @@ class block virtual std::optional destination_field () const; // Link field for state blocks virtual std::optional link_field () const; + // Representative field for open/change blocks + virtual std::optional representative_field () const; // Returns the source block hash for open/receive/state blocks that are receives nano::block_hash source () const noexcept; // Source block for open/receive blocks @@ -230,7 +231,6 @@ class open_block : public nano::block void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; nano::root const & root () const override; - nano::account const & representative () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void serialize_json (std::string &, bool = false) const override; @@ -251,6 +251,7 @@ class open_block : public nano::block public: // Open block fields std::optional account_field () const override; + std::optional representative_field () const override; std::optional source_field () const override; public: // Logging @@ -284,7 +285,6 @@ class change_block : public nano::block void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; nano::root const & root () const override; - nano::account const & representative () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void serialize_json (std::string &, bool = false) const override; @@ -303,6 +303,9 @@ class change_block : public nano::block uint64_t work; static std::size_t constexpr size = nano::change_hashables::size + sizeof (signature) + sizeof (work); +public: // Change block fields + std::optional representative_field () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; @@ -347,7 +350,6 @@ class state_block : public nano::block void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; nano::root const & root () const override; - nano::account const & representative () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void serialize_json (std::string &, bool = false) const override; @@ -370,6 +372,7 @@ class state_block : public nano::block std::optional account_field () const override; std::optional balance_field () const override; std::optional link_field () const override; + std::optional representative_field () const override; public: // Logging void operator() (nano::object_stream &) const override; diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 31105b7ac7..a18d22af3c 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1584,7 +1584,7 @@ int main (int argc, char * const * argv) // Calculate representative block if (block->type () == nano::block_type::open || block->type () == nano::block_type::change || block->type () == nano::block_type::state) { - calculated_representative = block->representative (); + calculated_representative = block->representative_field ().value (); } // Retrieving successor block hash hash = node->store.block.successor (transaction, hash); diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index cd95d848f7..f8265733fe 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -9,7 +9,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano block->account = block_a.account ().to_account (); block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); - block->representative = block_a.representative ().to_account (); + block->representative = block_a.representative_field ().value ().to_account (); block->balance = block_a.balance ().to_string_dec (); block->link = block_a.link_field ().value ().to_string (); block->link_as_account = block_a.link_field ().value ().to_account (); @@ -64,7 +64,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: block->hash = block_a.hash ().to_string (); block->source = block_a.source_field ().value ().to_string (); block->account = block_a.account ().to_account (); - block->representative = block_a.representative ().to_account (); + block->representative = block_a.representative_field ().value ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); return block; @@ -75,7 +75,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nan auto block (std::make_unique ()); block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); - block->representative = block_a.representative ().to_account (); + block->representative = block_a.representative_field ().value ().to_account (); block_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); return block; diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 386eb7c487..2442a23c33 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -685,10 +685,10 @@ void nano::json_handler::account_info () nano::account confirmed_representative{}; if (confirmed_frontier_block) { - confirmed_representative = confirmed_frontier_block->representative (); + confirmed_representative = confirmed_frontier_block->representative_field ().value_or (0); if (confirmed_representative.is_zero ()) { - confirmed_representative = node.ledger.block (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative (); + confirmed_representative = node.ledger.block (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative_field ().value (); } } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 5006752685..3e7f703466 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -2397,7 +2397,7 @@ TEST (rpc, account_representative_set) auto key2_open_block_hash = wallet.send_sync (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ()); ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), key2_open_block_hash)); auto key2_open_block = node->ledger.block (node->store.tx_begin_read (), key2_open_block_hash); - ASSERT_EQ (nano::dev::genesis_key.pub, key2_open_block->representative ()); + ASSERT_EQ (nano::dev::genesis_key.pub, key2_open_block->representative_field ().value ()); // now change the representative of key2 to be genesis auto const rpc_ctx = add_rpc (system, node); @@ -2416,7 +2416,7 @@ TEST (rpc, account_representative_set) auto block = node->ledger.block (node->store.tx_begin_read (), hash); ASSERT_NE (block, nullptr); ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), hash)); - ASSERT_EQ (key2.pub, block->representative ()); + ASSERT_EQ (key2.pub, block->representative_field ().value ()); } TEST (rpc, account_representative_set_work_disabled) diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 02447c33fd..74b70e6e29 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -85,7 +85,7 @@ class rollback_visitor : public nano::block_visitor auto amount = ledger.amount (transaction, hash).value (); auto destination_account = block_a.account (); auto source_account = ledger.account (transaction, block_a.hashables.source); - ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); + ledger.cache.rep_weights.representation_add (block_a.representative_field ().value (), 0 - amount); nano::account_info new_info; ledger.update_account (transaction, destination_account, new_info, new_info); ledger.store.block.del (transaction, hash); @@ -103,8 +103,8 @@ class rollback_visitor : public nano::block_visitor auto balance = ledger.balance (transaction, block_a.hashables.previous).value (); auto block = ledger.store.block.get (transaction, rep_block); release_assert (block != nullptr); - auto representative = block->representative (); - ledger.cache.rep_weights.representation_add_dual (block_a.representative (), 0 - balance, representative, balance); + auto representative = block->representative_field ().value (); + ledger.cache.rep_weights.representation_add_dual (block_a.hashables.representative, 0 - balance, representative, balance); ledger.store.block.del (transaction, hash); nano::account_info new_info (block_a.hashables.previous, representative, info->open_block, info->balance, nano::seconds_since_epoch (), info->block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, *info, new_info); @@ -129,13 +129,13 @@ class rollback_visitor : public nano::block_visitor // Move existing representation & add in amount delta auto block (ledger.store.block.get (transaction, rep_block_hash)); debug_assert (block != nullptr); - representative = block->representative (); - ledger.cache.rep_weights.representation_add_dual (representative, balance, block_a.representative (), 0 - block_a.hashables.balance.number ()); + representative = block->representative_field ().value (); + ledger.cache.rep_weights.representation_add_dual (representative, balance, block_a.hashables.representative, 0 - block_a.hashables.balance.number ()); } else { // Add in amount delta only - ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - block_a.hashables.balance.number ()); + ledger.cache.rep_weights.representation_add (block_a.hashables.representative, 0 - block_a.hashables.balance.number ()); } auto info = ledger.account_info (transaction, block_a.hashables.account); @@ -345,12 +345,12 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) if (!info.head.is_zero ()) { // Move existing representation & add in amount delta - ledger.cache.rep_weights.representation_add_dual (info.representative, 0 - info.balance.number (), block_a.representative (), block_a.hashables.balance.number ()); + ledger.cache.rep_weights.representation_add_dual (info.representative, 0 - info.balance.number (), block_a.hashables.representative, block_a.hashables.balance.number ()); } else { // Add in amount delta only - ledger.cache.rep_weights.representation_add (block_a.representative (), block_a.hashables.balance.number ()); + ledger.cache.rep_weights.representation_add (block_a.hashables.representative, block_a.hashables.balance.number ()); } if (is_send) @@ -364,7 +364,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) ledger.store.pending.del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ())); } - nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); + nano::account_info new_info (hash, block_a.hashables.representative, info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); ledger.update_account (transaction, block_a.hashables.account, info, new_info); if (!ledger.store.frontier.get (transaction, info.head).is_zero ()) { @@ -434,7 +434,7 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a) ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block); block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); - nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); + nano::account_info new_info (hash, block_a.hashables.representative, info.open_block.is_zero () ? hash : info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); ledger.update_account (transaction, block_a.hashables.account, info, new_info); if (!ledger.store.frontier.get (transaction, info.head).is_zero ()) { @@ -481,8 +481,8 @@ void ledger_processor::change_block (nano::change_block & block_a) block_a.sideband_set (nano::block_sideband (account, 0, info->balance, info->block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); auto balance = previous->balance (); - ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance.number (), info->representative, 0 - balance.number ()); - nano::account_info new_info (hash, block_a.representative (), info->open_block, info->balance, nano::seconds_since_epoch (), info->block_count + 1, nano::epoch::epoch_0); + ledger.cache.rep_weights.representation_add_dual (block_a.hashables.representative, balance.number (), info->representative, 0 - balance.number ()); + nano::account_info new_info (hash, block_a.hashables.representative, info->open_block, info->balance, nano::seconds_since_epoch (), info->block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, *info, new_info); ledger.store.frontier.del (transaction, block_a.hashables.previous); ledger.store.frontier.put (transaction, hash, account); @@ -665,9 +665,9 @@ void ledger_processor::open_block (nano::open_block & block_a) ledger.store.pending.del (transaction, key); block_a.sideband_set (nano::block_sideband (block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); - nano::account_info new_info (hash, block_a.representative (), hash, pending.amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0); + nano::account_info new_info (hash, block_a.representative_field ().value (), hash, pending.amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0); ledger.update_account (transaction, block_a.hashables.account, info, new_info); - ledger.cache.rep_weights.representation_add (block_a.representative (), pending.amount.number ()); + ledger.cache.rep_weights.representation_add (block_a.representative_field ().value (), pending.amount.number ()); ledger.store.frontier.put (transaction, hash, block_a.hashables.account); ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open); } From 5332f2c3f5240977221c9c0263450602d8b798ec Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Fri, 8 Mar 2024 14:27:59 +0000 Subject: [PATCH 170/190] Change block::previous to block::previous_field and return std::optional depending if the block has the field. Add block::previous with backwards compatibility and a todo to fix up usages to not check for sentinel values. --- nano/lib/blocks.cpp | 27 ++++++++++++++++++++------- nano/lib/blocks.hpp | 16 +++++++++------- 2 files changed, 29 insertions(+), 14 deletions(-) diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index c174a6d99e..060681ac12 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -293,6 +293,20 @@ nano::block_hash nano::block::source () const noexcept } } +// TODO - Remove comments below and fixup usages to not need to check .is_zero () +// std::optional nano::block::previous () const +nano::block_hash nano::block::previous () const noexcept +{ + std::optional result = previous_field (); + /* + if (result && result.value ().is_zero ()) + { + return std::nullopt; + } + return result;*/ + return result.value_or (0); +} + std::optional nano::block::account_field () const { return std::nullopt; @@ -573,7 +587,7 @@ bool nano::send_block::operator== (nano::send_block const & other_a) const return result; } -nano::block_hash const & nano::send_block::previous () const +std::optional nano::send_block::previous_field () const { return hashables.previous; } @@ -743,10 +757,9 @@ void nano::open_block::block_work_set (uint64_t work_a) work = work_a; } -nano::block_hash const & nano::open_block::previous () const +std::optional nano::open_block::previous_field () const { - static nano::block_hash result{ 0 }; - return result; + return std::nullopt; } std::optional nano::open_block::account_field () const @@ -1015,7 +1028,7 @@ void nano::change_block::block_work_set (uint64_t work_a) work = work_a; } -nano::block_hash const & nano::change_block::previous () const +std::optional nano::change_block::previous_field () const { return hashables.previous; } @@ -1314,7 +1327,7 @@ void nano::state_block::block_work_set (uint64_t work_a) work = work_a; } -nano::block_hash const & nano::state_block::previous () const +std::optional nano::state_block::previous_field () const { return hashables.previous; } @@ -1801,7 +1814,7 @@ bool nano::receive_block::valid_predecessor (nano::block const & block_a) const return result; } -nano::block_hash const & nano::receive_block::previous () const +std::optional nano::receive_block::previous_field () const { return hashables.previous; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index ad860a1bc4..d6cca74374 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -33,8 +33,6 @@ class block virtual void hash (blake2b_state &) const = 0; virtual uint64_t block_work () const = 0; virtual void block_work_set (uint64_t) = 0; - // Previous block in account's chain, zero for open block - virtual nano::block_hash const & previous () const = 0; // Previous block or account number for open blocks virtual nano::root const & root () const = 0; // Qualified root value based on previous() and root() @@ -73,6 +71,10 @@ class block virtual std::optional destination_field () const; // Link field for state blocks virtual std::optional link_field () const; + // Previous block if field exists or 0 + nano::block_hash previous () const noexcept; + // Previous block in chain if the field exists + virtual std::optional previous_field () const = 0; // Representative field for open/change blocks virtual std::optional representative_field () const; // Returns the source block hash for open/receive/state blocks that are receives @@ -122,7 +124,6 @@ class send_block : public nano::block void hash (blake2b_state &) const override; uint64_t block_work () const override; void block_work_set (uint64_t) override; - nano::block_hash const & previous () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -145,6 +146,7 @@ class send_block : public nano::block public: // Send block fields std::optional balance_field () const override; std::optional destination_field () const override; + std::optional previous_field () const override; public: // Logging void operator() (nano::object_stream &) const override; @@ -175,7 +177,6 @@ class receive_block : public nano::block void hash (blake2b_state &) const override; uint64_t block_work () const override; void block_work_set (uint64_t) override; - nano::block_hash const & previous () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -196,6 +197,7 @@ class receive_block : public nano::block static std::size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); public: // Receive block fields + std::optional previous_field () const override; std::optional source_field () const override; public: // Logging @@ -229,7 +231,6 @@ class open_block : public nano::block void hash (blake2b_state &) const override; uint64_t block_work () const override; void block_work_set (uint64_t) override; - nano::block_hash const & previous () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -251,6 +252,7 @@ class open_block : public nano::block public: // Open block fields std::optional account_field () const override; + std::optional previous_field () const override; std::optional representative_field () const override; std::optional source_field () const override; @@ -283,7 +285,6 @@ class change_block : public nano::block void hash (blake2b_state &) const override; uint64_t block_work () const override; void block_work_set (uint64_t) override; - nano::block_hash const & previous () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -304,6 +305,7 @@ class change_block : public nano::block static std::size_t constexpr size = nano::change_hashables::size + sizeof (signature) + sizeof (work); public: // Change block fields + std::optional previous_field () const override; std::optional representative_field () const override; public: // Logging @@ -348,7 +350,6 @@ class state_block : public nano::block void hash (blake2b_state &) const override; uint64_t block_work () const override; void block_work_set (uint64_t) override; - nano::block_hash const & previous () const override; nano::root const & root () const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -372,6 +373,7 @@ class state_block : public nano::block std::optional account_field () const override; std::optional balance_field () const override; std::optional link_field () const override; + std::optional previous_field () const override; std::optional representative_field () const override; public: // Logging From 5c7b115c15cd8eaa6eff191921e520bceb3d573d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sat, 9 Mar 2024 21:38:30 +0100 Subject: [PATCH 171/190] Use start/stop pattern in `block_processor` (#4462) --- nano/node/blockprocessor.cpp | 25 +++++++++++++++++++------ nano/node/blockprocessor.hpp | 13 ++++++++----- nano/node/node.cpp | 1 + 3 files changed, 28 insertions(+), 11 deletions(-) diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 92efa88e28..b9f8544d78 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -46,9 +46,21 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas block_processed.notify (result, context); } }); - processing_thread = std::thread ([this] () { +} + +nano::block_processor::~block_processor () +{ + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); +} + +void nano::block_processor::start () +{ + debug_assert (!thread.joinable ()); + + thread = std::thread ([this] () { nano::thread_role::set (nano::thread_role::name::block_processing); - this->process_blocks (); + run (); }); } @@ -59,7 +71,10 @@ void nano::block_processor::stop () stopped = true; } condition.notify_all (); - nano::join_or_pass (processing_thread); + if (thread.joinable ()) + { + thread.join (); + } } std::size_t nano::block_processor::size () @@ -172,14 +187,13 @@ void nano::block_processor::rollback_competitor (store::write_transaction const } } -void nano::block_processor::process_blocks () +void nano::block_processor::run () { nano::unique_lock lock{ mutex }; while (!stopped) { if (have_blocks_ready ()) { - active = true; lock.unlock (); auto processed = process_batch (lock); @@ -194,7 +208,6 @@ void nano::block_processor::process_blocks () batch_processed.notify (processed); lock.lock (); - active = false; } else { diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index f0dae027c5..0d020e8b16 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -67,8 +67,11 @@ class block_processor final public: block_processor (nano::node &, nano::write_database_queue &); + ~block_processor (); + void start (); void stop (); + std::size_t size (); bool full (); bool half_full (); @@ -78,7 +81,7 @@ class block_processor final bool should_log (); bool have_blocks_ready (); bool have_blocks (); - void process_blocks (); + std::unique_ptr collect_container_info (std::string const & name); std::atomic flushing{ false }; @@ -93,6 +96,7 @@ class block_processor final nano::observer_set const &> rolled_back; private: + void run (); // Roll back block in the ledger that conflicts with 'block' void rollback_competitor (store::write_transaction const &, nano::block const & block); nano::block_status process_one (store::write_transaction const &, context const &, bool forced = false); @@ -106,15 +110,14 @@ class block_processor final nano::write_database_queue & write_database_queue; private: - bool stopped{ false }; - bool active{ false }; - std::deque blocks; std::deque forced; std::chrono::steady_clock::time_point next_log; + + bool stopped{ false }; nano::condition_variable condition; nano::mutex mutex{ mutex_identifier (mutexes::block_processor) }; - std::thread processing_thread; + std::thread thread; }; } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 0a49c4c745..033a98860b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -635,6 +635,7 @@ void nano::node::start () } wallets.start (); vote_processor.start (); + block_processor.start (); active.start (); generator.start (); final_generator.start (); From 14a05695f74c1e9ebaa77aaa202141e65d78c19c Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 15:14:40 +0000 Subject: [PATCH 172/190] Remove unnecessary inclusion of rep_weights from ledger.hpp --- nano/secure/ledger.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 5f1b1e49b8..f2477222e6 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include From 14c4c6ff7116b6ab16e3fb9dad98d4aee71a784d Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 15:22:45 +0000 Subject: [PATCH 173/190] Remove inclusion of ledger.hpp from election.hpp --- nano/node/election.hpp | 1 - nano/node/websocket.cpp | 1 + nano/node/websocket.hpp | 16 ++++++++++------ 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 04dd20980b..258c5655e2 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index e33d1c8898..68f870a3c0 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 4b58bae7f2..6212198400 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -20,15 +20,19 @@ namespace nano { class block; -class wallets; -class logger; -class vote; class election_status; +enum class election_status_type : uint8_t; +class ledger; +class logger; +class node_observers; class telemetry_data; class tls_config; -class node_observers; -enum class election_status_type : uint8_t; +class vote; +class wallets; +} +namespace nano +{ namespace websocket { class listener; @@ -382,4 +386,4 @@ class websocket_server // TODO: Encapsulate, this is public just because existing code needs it std::shared_ptr server; }; -} +} // namespace nano From caef5dcabcf6a5ef87ead342935a6a18a4ec362c Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 15:32:30 +0000 Subject: [PATCH 174/190] Move nano::generate_cache to its own file. --- nano/node/nodeconfig.hpp | 3 ++- nano/secure/CMakeLists.txt | 2 ++ nano/secure/common.cpp | 8 -------- nano/secure/common.hpp | 14 -------------- nano/secure/generate_cache_flags.cpp | 9 +++++++++ nano/secure/generate_cache_flags.hpp | 18 ++++++++++++++++++ nano/secure/ledger.cpp | 10 +++++----- nano/secure/ledger.hpp | 5 +++-- 8 files changed, 39 insertions(+), 30 deletions(-) create mode 100644 nano/secure/generate_cache_flags.cpp create mode 100644 nano/secure/generate_cache_flags.hpp diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index d51b342684..252f6e07fb 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -169,7 +170,7 @@ class node_flags final bool read_only{ false }; bool disable_connection_cleanup{ false }; nano::confirmation_height_mode confirmation_height_processor_mode{ nano::confirmation_height_mode::automatic }; - nano::generate_cache generate_cache; + nano::generate_cache_flags generate_cache; bool inactive_node{ false }; std::size_t block_processor_batch_size{ 0 }; std::size_t block_processor_full_size{ 65536 }; diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index f80ac9d8b3..11f3f8c425 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -41,6 +41,8 @@ add_library( ${CMAKE_BINARY_DIR}/bootstrap_weights_beta.cpp common.hpp common.cpp + generate_cache_flags.hpp + generate_cache_flags.cpp ledger.hpp ledger.cpp network_filter.hpp diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 6b91dd6766..0a050c9720 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -484,14 +484,6 @@ nano::block_hash const & nano::unchecked_key::key () const return previous; } -void nano::generate_cache::enable_all () -{ - reps = true; - cemented_count = true; - unchecked_count = true; - account_count = true; -} - std::string_view nano::to_string (nano::block_status code) { return magic_enum::enum_name (code); diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 9ce6858258..c8dd6389ea 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -405,20 +405,6 @@ enum class confirmation_height_mode bounded }; -/* Holds flags for various cacheable data. For most CLI operations caching is unnecessary - * (e.g getting the cemented block count) so it can be disabled for performance reasons. */ -class generate_cache -{ -public: - bool reps = true; - bool cemented_count = true; - bool unchecked_count = true; - bool account_count = true; - bool block_count = true; - - void enable_all (); -}; - /* Holds an in-memory cache of various counts */ class ledger_cache { diff --git a/nano/secure/generate_cache_flags.cpp b/nano/secure/generate_cache_flags.cpp new file mode 100644 index 0000000000..912932ceed --- /dev/null +++ b/nano/secure/generate_cache_flags.cpp @@ -0,0 +1,9 @@ +#include + +void nano::generate_cache_flags::enable_all () +{ + reps = true; + cemented_count = true; + unchecked_count = true; + account_count = true; +} diff --git a/nano/secure/generate_cache_flags.hpp b/nano/secure/generate_cache_flags.hpp new file mode 100644 index 0000000000..29445e53d8 --- /dev/null +++ b/nano/secure/generate_cache_flags.hpp @@ -0,0 +1,18 @@ +#pragma once + +namespace nano +{ +/* Holds flags for various cacheable data. For most CLI operations caching is unnecessary + * (e.g getting the cemented block count) so it can be disabled for performance reasons. */ +class generate_cache_flags +{ +public: + bool reps = true; + bool cemented_count = true; + bool unchecked_count = true; + bool account_count = true; + bool block_count = true; + + void enable_all (); +}; +} diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 74b70e6e29..ca6ec8b2f2 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -750,7 +750,7 @@ void representative_visitor::state_block (nano::state_block const & block_a) } } // namespace -nano::ledger::ledger (nano::store::component & store_a, nano::stats & stat_a, nano::ledger_constants & constants, nano::generate_cache const & generate_cache_a) : +nano::ledger::ledger (nano::store::component & store_a, nano::stats & stat_a, nano::ledger_constants & constants, nano::generate_cache_flags const & generate_cache_flags_a) : constants{ constants }, store{ store_a }, stats{ stat_a }, @@ -758,13 +758,13 @@ nano::ledger::ledger (nano::store::component & store_a, nano::stats & stat_a, na { if (!store.init_error ()) { - initialize (generate_cache_a); + initialize (generate_cache_flags_a); } } -void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) +void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache_flags_a) { - if (generate_cache_a.reps || generate_cache_a.account_count || generate_cache_a.block_count) + if (generate_cache_flags_a.reps || generate_cache_flags_a.account_count || generate_cache_flags_a.block_count) { store.account.for_each_par ( [this] (store::read_transaction const & /*unused*/, store::iterator i, store::iterator n) { @@ -784,7 +784,7 @@ void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) }); } - if (generate_cache_a.cemented_count) + if (generate_cache_flags_a.cemented_count) { store.confirmation_height.for_each_par ( [this] (store::read_transaction const & /*unused*/, store::iterator i, store::iterator n) { diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index f2477222e6..321adaec87 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -2,6 +2,7 @@ #include #include +#include #include @@ -28,7 +29,7 @@ class uncemented_info class ledger final { public: - ledger (nano::store::component &, nano::stats &, nano::ledger_constants & constants, nano::generate_cache const & = nano::generate_cache ()); + ledger (nano::store::component &, nano::stats &, nano::ledger_constants & constants, nano::generate_cache_flags const & = nano::generate_cache_flags{}); /** * Returns the account for a given hash * Returns std::nullopt if the block doesn't exist or has been pruned @@ -87,7 +88,7 @@ class ledger final bool pruning{ false }; private: - void initialize (nano::generate_cache const &); + void initialize (nano::generate_cache_flags const &); }; std::unique_ptr collect_container_info (ledger & ledger, std::string const & name); From 12571dace3da5ad5a2869e39e287bd21fe84747d Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 15:59:15 +0000 Subject: [PATCH 175/190] Move nano::account_info in to its own file. --- nano/node/backlog_population.hpp | 3 +- nano/node/scheduler/optimistic.hpp | 5 ++- nano/secure/CMakeLists.txt | 2 + nano/secure/account_info.cpp | 60 ++++++++++++++++++++++++++++++ nano/secure/account_info.hpp | 32 ++++++++++++++++ nano/secure/common.cpp | 59 ----------------------------- nano/secure/common.hpp | 23 ------------ nano/secure/ledger.hpp | 1 + nano/store/account.hpp | 2 + nano/store/db_val.hpp | 14 ++----- nano/store/db_val_impl.hpp | 17 +++++++++ nano/test_common/testutil.hpp | 1 + 12 files changed, 123 insertions(+), 96 deletions(-) create mode 100644 nano/secure/account_info.cpp create mode 100644 nano/secure/account_info.hpp diff --git a/nano/node/backlog_population.hpp b/nano/node/backlog_population.hpp index 41116e5f29..7bc1a6d00e 100644 --- a/nano/node/backlog_population.hpp +++ b/nano/node/backlog_population.hpp @@ -15,8 +15,9 @@ class transaction; } namespace nano { -class stats; +class account_info; class election_scheduler; +class stats; class backlog_population final { diff --git a/nano/node/scheduler/optimistic.hpp b/nano/node/scheduler/optimistic.hpp index c590c8f17d..547bd7e8c1 100644 --- a/nano/node/scheduler/optimistic.hpp +++ b/nano/node/scheduler/optimistic.hpp @@ -22,9 +22,10 @@ namespace mi = boost::multi_index; namespace nano { -class node; -class ledger; +class account_info; class active_transactions; +class ledger; +class node; } namespace nano::scheduler diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index 11f3f8c425..af06e26fc1 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -39,6 +39,8 @@ add_library( ${PLATFORM_SECURE_SOURCE} ${CMAKE_BINARY_DIR}/bootstrap_weights_live.cpp ${CMAKE_BINARY_DIR}/bootstrap_weights_beta.cpp + account_info.hpp + account_info.cpp common.hpp common.cpp generate_cache_flags.hpp diff --git a/nano/secure/account_info.cpp b/nano/secure/account_info.cpp new file mode 100644 index 0000000000..b478f95e71 --- /dev/null +++ b/nano/secure/account_info.cpp @@ -0,0 +1,60 @@ +#include + +nano::account_info::account_info (nano::block_hash const & head_a, nano::account const & representative_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, nano::seconds_t modified_a, uint64_t block_count_a, nano::epoch epoch_a) : + head (head_a), + representative (representative_a), + open_block (open_block_a), + balance (balance_a), + modified (modified_a), + block_count (block_count_a), + epoch_m (epoch_a) +{ +} + +bool nano::account_info::deserialize (nano::stream & stream_a) +{ + auto error (false); + try + { + nano::read (stream_a, head.bytes); + nano::read (stream_a, representative.bytes); + nano::read (stream_a, open_block.bytes); + nano::read (stream_a, balance.bytes); + nano::read (stream_a, modified); + nano::read (stream_a, block_count); + nano::read (stream_a, epoch_m); + } + catch (std::runtime_error const &) + { + error = true; + } + + return error; +} + +bool nano::account_info::operator== (nano::account_info const & other_a) const +{ + return head == other_a.head && representative == other_a.representative && open_block == other_a.open_block && balance == other_a.balance && modified == other_a.modified && block_count == other_a.block_count && epoch () == other_a.epoch (); +} + +bool nano::account_info::operator!= (nano::account_info const & other_a) const +{ + return !(*this == other_a); +} + +size_t nano::account_info::db_size () const +{ + 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); +} + +nano::epoch nano::account_info::epoch () const +{ + return epoch_m; +} diff --git a/nano/secure/account_info.hpp b/nano/secure/account_info.hpp new file mode 100644 index 0000000000..422515fa87 --- /dev/null +++ b/nano/secure/account_info.hpp @@ -0,0 +1,32 @@ +#pragma once + +#include +#include +#include +#include + +namespace nano +{ +/** + * Latest information about an account + */ +class account_info final +{ +public: + account_info () = default; + account_info (nano::block_hash const &, nano::account const &, nano::block_hash const &, nano::amount const &, nano::seconds_t modified, uint64_t, epoch); + bool deserialize (nano::stream &); + bool operator== (nano::account_info const &) const; + bool operator!= (nano::account_info const &) const; + size_t db_size () const; + nano::epoch epoch () const; + nano::block_hash head{ 0 }; + nano::account representative{}; + nano::block_hash open_block{ 0 }; + nano::amount balance{ 0 }; + /** Seconds since posix epoch */ + nano::seconds_t modified{ 0 }; + uint64_t block_count{ 0 }; + nano::epoch epoch_m{ nano::epoch::epoch_0 }; +}; +} // namespace nano diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 0a050c9720..ae2b1682fc 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -218,65 +218,6 @@ nano::keypair::keypair (std::string const & prv_a) ed25519_publickey (prv.bytes.data (), pub.bytes.data ()); } -nano::account_info::account_info (nano::block_hash const & head_a, nano::account const & representative_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, nano::seconds_t modified_a, uint64_t block_count_a, nano::epoch epoch_a) : - head (head_a), - representative (representative_a), - open_block (open_block_a), - balance (balance_a), - modified (modified_a), - block_count (block_count_a), - epoch_m (epoch_a) -{ -} - -bool nano::account_info::deserialize (nano::stream & stream_a) -{ - auto error (false); - try - { - nano::read (stream_a, head.bytes); - nano::read (stream_a, representative.bytes); - nano::read (stream_a, open_block.bytes); - nano::read (stream_a, balance.bytes); - nano::read (stream_a, modified); - nano::read (stream_a, block_count); - nano::read (stream_a, epoch_m); - } - catch (std::runtime_error const &) - { - error = true; - } - - return error; -} - -bool nano::account_info::operator== (nano::account_info const & other_a) const -{ - return head == other_a.head && representative == other_a.representative && open_block == other_a.open_block && balance == other_a.balance && modified == other_a.modified && block_count == other_a.block_count && epoch () == other_a.epoch (); -} - -bool nano::account_info::operator!= (nano::account_info const & other_a) const -{ - return !(*this == other_a); -} - -size_t nano::account_info::db_size () const -{ - 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); -} - -nano::epoch nano::account_info::epoch () const -{ - return epoch_m; -} - nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) : source (source_a), amount (amount_a), diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index c8dd6389ea..87faf17a1e 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -98,29 +98,6 @@ class keypair nano::raw_key prv; }; -/** - * Latest information about an account - */ -class account_info final -{ -public: - account_info () = default; - account_info (nano::block_hash const &, nano::account const &, nano::block_hash const &, nano::amount const &, nano::seconds_t modified, uint64_t, epoch); - bool deserialize (nano::stream &); - bool operator== (nano::account_info const &) const; - bool operator!= (nano::account_info const &) const; - size_t db_size () const; - nano::epoch epoch () const; - nano::block_hash head{ 0 }; - nano::account representative{}; - nano::block_hash open_block{ 0 }; - nano::amount balance{ 0 }; - /** Seconds since posix epoch */ - nano::seconds_t modified{ 0 }; - uint64_t block_count{ 0 }; - nano::epoch epoch_m{ nano::epoch::epoch_0 }; -}; - /** * Information on an uncollected send */ diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 321adaec87..da42b79519 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include diff --git a/nano/store/account.hpp b/nano/store/account.hpp index 9d20fdd384..749cd9c842 100644 --- a/nano/store/account.hpp +++ b/nano/store/account.hpp @@ -2,12 +2,14 @@ #include #include +#include #include #include namespace nano { +class account_info; class block_hash; } namespace nano::store diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp index a9fc4cc8d8..cdabac606d 100644 --- a/nano/store/db_val.hpp +++ b/nano/store/db_val.hpp @@ -11,6 +11,7 @@ namespace nano { +class account_info; class block; } @@ -58,10 +59,7 @@ class db_val { } - db_val (nano::account_info const & val_a) : - db_val (val_a.db_size (), const_cast (&val_a)) - { - } + db_val (nano::account_info const & val_a); db_val (nano::pending_info const & val_a) : db_val (val_a.db_size (), const_cast (&val_a)) @@ -110,13 +108,7 @@ class db_val convert_buffer_to_value (); } - explicit operator nano::account_info () const - { - nano::account_info result; - debug_assert (size () == result.db_size ()); - std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); - return result; - } + explicit operator nano::account_info () const; explicit operator block_info () const { diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp index a8de6f0079..1555fe856d 100644 --- a/nano/store/db_val_impl.hpp +++ b/nano/store/db_val_impl.hpp @@ -1,6 +1,14 @@ +#pragma once + #include +#include #include +template +nano::store::db_val::db_val (nano::account_info const & val_a) : + db_val (val_a.db_size (), const_cast (&val_a)) +{ +} template nano::store::db_val::db_val (std::shared_ptr const & val_a) : buffer (std::make_shared> ()) @@ -12,6 +20,15 @@ nano::store::db_val::db_val (std::shared_ptr const & val_a) : convert_buffer_to_value (); } +template +nano::store::db_val::operator nano::account_info () const +{ + nano::account_info result; + debug_assert (size () == result.db_size ()); + std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); + return result; +} + template nano::store::db_val::operator std::shared_ptr () const { diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index 286de73207..60821e7ddd 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -3,6 +3,7 @@ #include #include #include +#include #include From 641047ecc2cb620c5d0be44f464051b875d429ab Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 16:08:23 +0000 Subject: [PATCH 176/190] Move nano::ledger_cache to its own file. --- nano/secure/CMakeLists.txt | 2 ++ nano/secure/common.hpp | 12 ------------ nano/secure/ledger.hpp | 1 + nano/secure/ledger_cache.cpp | 0 nano/secure/ledger_cache.hpp | 20 ++++++++++++++++++++ nano/store/component.cpp | 1 + 6 files changed, 24 insertions(+), 12 deletions(-) create mode 100644 nano/secure/ledger_cache.cpp create mode 100644 nano/secure/ledger_cache.hpp diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index af06e26fc1..84a2de2052 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -47,6 +47,8 @@ add_library( generate_cache_flags.cpp ledger.hpp ledger.cpp + ledger_cache.hpp + ledger_cache.cpp network_filter.hpp network_filter.cpp utility.hpp diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 87faf17a1e..018e929c5d 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -382,18 +382,6 @@ enum class confirmation_height_mode bounded }; -/* Holds an in-memory cache of various counts */ -class ledger_cache -{ -public: - nano::rep_weights rep_weights; - std::atomic cemented_count{ 0 }; - std::atomic block_count{ 0 }; - std::atomic pruned_count{ 0 }; - std::atomic account_count{ 0 }; - std::atomic final_votes_confirmation_canary{ false }; -}; - /* Defines the possible states for an election to stop in */ enum class election_status_type : uint8_t { diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index da42b79519..783e767f4f 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include diff --git a/nano/secure/ledger_cache.cpp b/nano/secure/ledger_cache.cpp new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nano/secure/ledger_cache.hpp b/nano/secure/ledger_cache.hpp new file mode 100644 index 0000000000..726a1e1119 --- /dev/null +++ b/nano/secure/ledger_cache.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include + +#include + +namespace nano +{ +/* Holds an in-memory cache of various counts */ +class ledger_cache +{ +public: + nano::rep_weights rep_weights; + std::atomic cemented_count{ 0 }; + std::atomic block_count{ 0 }; + std::atomic pruned_count{ 0 }; + std::atomic account_count{ 0 }; + std::atomic final_votes_confirmation_canary{ false }; +}; +} diff --git a/nano/store/component.cpp b/nano/store/component.cpp index 67826f6345..838a7b9cb7 100644 --- a/nano/store/component.cpp +++ b/nano/store/component.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include From f5a3c5630e4b28bbe8e50cffedd33ea688d95642 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 16:23:26 +0000 Subject: [PATCH 177/190] Move nano::pending_info and nano::pending_key in to their own file. --- nano/node/bootstrap/bootstrap_bulk_pull.hpp | 1 + nano/secure/CMakeLists.txt | 2 + nano/secure/common.cpp | 66 -------------------- nano/secure/common.hpp | 27 -------- nano/secure/ledger.hpp | 2 + nano/secure/pending_info.cpp | 69 +++++++++++++++++++++ nano/secure/pending_info.hpp | 35 +++++++++++ nano/store/db_val.hpp | 31 ++------- nano/store/db_val_impl.hpp | 34 ++++++++++ nano/store/pending.hpp | 2 + 10 files changed, 151 insertions(+), 118 deletions(-) create mode 100644 nano/secure/pending_info.cpp create mode 100644 nano/secure/pending_info.hpp diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.hpp b/nano/node/bootstrap/bootstrap_bulk_pull.hpp index b84a184428..a3e901e666 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.hpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.hpp @@ -2,6 +2,7 @@ #include #include +#include #include diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index 84a2de2052..f9ca76129a 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -51,6 +51,8 @@ add_library( ledger_cache.cpp network_filter.hpp network_filter.cpp + pending_info.hpp + pending_info.cpp utility.hpp utility.cpp vote.hpp diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index ae2b1682fc..d1943ba2cb 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -218,72 +218,6 @@ nano::keypair::keypair (std::string const & prv_a) ed25519_publickey (prv.bytes.data (), pub.bytes.data ()); } -nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) : - source (source_a), - amount (amount_a), - epoch (epoch_a) -{ -} - -bool nano::pending_info::deserialize (nano::stream & stream_a) -{ - auto error (false); - try - { - nano::read (stream_a, source.bytes); - nano::read (stream_a, amount.bytes); - nano::read (stream_a, epoch); - } - catch (std::runtime_error const &) - { - error = true; - } - - return error; -} - -size_t nano::pending_info::db_size () const -{ - return sizeof (source) + sizeof (amount) + sizeof (epoch); -} - -bool nano::pending_info::operator== (nano::pending_info const & other_a) const -{ - return source == other_a.source && amount == other_a.amount && epoch == other_a.epoch; -} - -nano::pending_key::pending_key (nano::account const & account_a, nano::block_hash const & hash_a) : - account (account_a), - hash (hash_a) -{ -} - -bool nano::pending_key::deserialize (nano::stream & stream_a) -{ - auto error (false); - try - { - nano::read (stream_a, account.bytes); - nano::read (stream_a, hash.bytes); - } - catch (std::runtime_error const &) - { - error = true; - } - - return error; -} - -bool nano::pending_key::operator== (nano::pending_key const & other_a) const -{ - return account == other_a.account && hash == other_a.hash; -} - -nano::account const & nano::pending_key::key () const -{ - return account; -} - nano::unchecked_info::unchecked_info (std::shared_ptr const & block_a) : block (block_a), modified_m (nano::seconds_since_epoch ()) diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 018e929c5d..e1d43fec89 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -98,33 +98,6 @@ class keypair nano::raw_key prv; }; -/** - * Information on an uncollected send - */ -class pending_info final -{ -public: - pending_info () = default; - pending_info (nano::account const &, nano::amount const &, nano::epoch); - size_t db_size () const; - bool deserialize (nano::stream &); - bool operator== (nano::pending_info const &) const; - nano::account source{}; - nano::amount amount{ 0 }; - nano::epoch epoch{ nano::epoch::epoch_0 }; -}; -class pending_key final -{ -public: - pending_key () = default; - pending_key (nano::account const &, nano::block_hash const &); - bool deserialize (nano::stream &); - bool operator== (nano::pending_key const &) const; - nano::account const & key () const; - nano::account account{}; - nano::block_hash hash{ 0 }; -}; - class endpoint_key final { public: diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 783e767f4f..cb05589d75 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -17,6 +17,8 @@ class write_transaction; namespace nano { +class pending_info; +class pending_key; class stats; class uncemented_info diff --git a/nano/secure/pending_info.cpp b/nano/secure/pending_info.cpp new file mode 100644 index 0000000000..2989239f1f --- /dev/null +++ b/nano/secure/pending_info.cpp @@ -0,0 +1,69 @@ +#pragma once + +#include + +nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) : + source (source_a), + amount (amount_a), + epoch (epoch_a) +{ +} + +bool nano::pending_info::deserialize (nano::stream & stream_a) +{ + auto error (false); + try + { + nano::read (stream_a, source.bytes); + nano::read (stream_a, amount.bytes); + nano::read (stream_a, epoch); + } + catch (std::runtime_error const &) + { + error = true; + } + + return error; +} + +size_t nano::pending_info::db_size () const +{ + return sizeof (source) + sizeof (amount) + sizeof (epoch); +} + +bool nano::pending_info::operator== (nano::pending_info const & other_a) const +{ + return source == other_a.source && amount == other_a.amount && epoch == other_a.epoch; +} + +nano::pending_key::pending_key (nano::account const & account_a, nano::block_hash const & hash_a) : + account (account_a), + hash (hash_a) +{ +} + +bool nano::pending_key::deserialize (nano::stream & stream_a) +{ + auto error (false); + try + { + nano::read (stream_a, account.bytes); + nano::read (stream_a, hash.bytes); + } + catch (std::runtime_error const &) + { + error = true; + } + + return error; +} + +bool nano::pending_key::operator== (nano::pending_key const & other_a) const +{ + return account == other_a.account && hash == other_a.hash; +} + +nano::account const & nano::pending_key::key () const +{ + return account; +} diff --git a/nano/secure/pending_info.hpp b/nano/secure/pending_info.hpp new file mode 100644 index 0000000000..4e69460399 --- /dev/null +++ b/nano/secure/pending_info.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include +#include + +namespace nano +{ +/** + * Information on an uncollected send + */ +class pending_info final +{ +public: + pending_info () = default; + pending_info (nano::account const &, nano::amount const &, nano::epoch); + size_t db_size () const; + bool deserialize (nano::stream &); + bool operator== (nano::pending_info const &) const; + nano::account source{}; + nano::amount amount{ 0 }; + nano::epoch epoch{ nano::epoch::epoch_0 }; +}; +class pending_key final +{ +public: + pending_key () = default; + pending_key (nano::account const &, nano::block_hash const &); + bool deserialize (nano::stream &); + bool operator== (nano::pending_key const &) const; + nano::account const & key () const; + nano::account account{}; + nano::block_hash hash{ 0 }; +}; +} // namespace nano diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp index cdabac606d..fee58d9e0d 100644 --- a/nano/store/db_val.hpp +++ b/nano/store/db_val.hpp @@ -13,6 +13,8 @@ namespace nano { class account_info; class block; +class pending_info; +class pending_key; } namespace nano::store @@ -61,17 +63,9 @@ class db_val db_val (nano::account_info const & val_a); - db_val (nano::pending_info const & val_a) : - db_val (val_a.db_size (), const_cast (&val_a)) - { - static_assert (std::is_standard_layout::value, "Standard layout is required"); - } + db_val (nano::pending_info const & val_a); - db_val (nano::pending_key const & val_a) : - db_val (sizeof (val_a), const_cast (&val_a)) - { - static_assert (std::is_standard_layout::value, "Standard layout is required"); - } + db_val (nano::pending_key const & val_a); db_val (nano::confirmation_height_info const & val_a) : buffer (std::make_shared> ()) @@ -119,22 +113,9 @@ class db_val return result; } - explicit operator nano::pending_info () const - { - nano::pending_info result; - debug_assert (size () == result.db_size ()); - std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); - return result; - } + explicit operator nano::pending_info () const; - explicit operator nano::pending_key () const - { - nano::pending_key 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; - } + explicit operator nano::pending_key () const; explicit operator nano::confirmation_height_info () const { diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp index 1555fe856d..c8ee18624f 100644 --- a/nano/store/db_val_impl.hpp +++ b/nano/store/db_val_impl.hpp @@ -2,6 +2,7 @@ #include #include +#include #include template @@ -20,6 +21,20 @@ nano::store::db_val::db_val (std::shared_ptr const & val_a) : convert_buffer_to_value (); } +template +nano::store::db_val::db_val (nano::pending_info const & val_a) : + db_val (val_a.db_size (), const_cast (&val_a)) +{ + static_assert (std::is_standard_layout::value, "Standard layout is required"); +} + +template +nano::store::db_val::db_val (nano::pending_key const & val_a) : + db_val (sizeof (val_a), const_cast (&val_a)) +{ + static_assert (std::is_standard_layout::value, "Standard layout is required"); +} + template nano::store::db_val::operator nano::account_info () const { @@ -48,3 +63,22 @@ nano::store::db_val::operator nano::store::block_w_sideband () const block_w_sideband.block->sideband_set (block_w_sideband.sideband); return block_w_sideband; } + +template +nano::store::db_val::operator nano::pending_info () const +{ + nano::pending_info result; + debug_assert (size () == result.db_size ()); + std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + result.db_size (), reinterpret_cast (&result)); + return result; +} + +template +nano::store::db_val::operator nano::pending_key () const +{ + nano::pending_key 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; +} diff --git a/nano/store/pending.hpp b/nano/store/pending.hpp index 6c5b379323..1531c7f7cc 100644 --- a/nano/store/pending.hpp +++ b/nano/store/pending.hpp @@ -9,6 +9,8 @@ namespace nano { class block_hash; +class pending_info; +class pending_key; } namespace nano::store { From 95df470f318a4bdc1b1cfe66e3f8f644a0084a22 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 16:39:03 +0000 Subject: [PATCH 178/190] Remove inclusion of secure/common.hpp from ledger.hpp and forward declare needed types. --- nano/secure/ledger.hpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index cb05589d75..864902a826 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -1,8 +1,8 @@ #pragma once +#include #include #include -#include #include #include @@ -17,6 +17,10 @@ class write_transaction; namespace nano { +class block; +enum class block_status; +enum class epoch : uint8_t; +class ledger_constants; class pending_info; class pending_key; class stats; From af36d9ff358f9a3ba7fc9f7a915c33cb3c1839e9 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 16:49:32 +0000 Subject: [PATCH 179/190] Remove decltype to reference nested class within nano::ledger --- nano/node/node.cpp | 2 +- nano/node/node.hpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 033a98860b..f6a9cdeed9 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1297,7 +1297,7 @@ bool nano::node::init_error () const return store.init_error () || wallets_store.init_error (); } -std::pair nano::node::get_bootstrap_weights () const +std::pair> nano::node::get_bootstrap_weights () const { std::unordered_map weights; uint8_t const * weight_buffer = network_params.network.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta; diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 3c09cff685..4f52fdddfd 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -123,7 +123,7 @@ class node final : public std::enable_shared_from_this void ongoing_online_weight_calculation_queue (); bool online () const; bool init_error () const; - std::pair get_bootstrap_weights () const; + std::pair> get_bootstrap_weights () const; uint64_t get_confirmation_height (store::transaction const &, nano::account &); /* * Attempts to bootstrap block. This is the best effort, there is no guarantee that the block will be bootstrapped. From a0b1f28791daa8febab172c3e2715e1415bf7947 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Sun, 10 Mar 2024 16:55:17 +0000 Subject: [PATCH 180/190] Remove reference to ledger.hpp from node.hpp and forward declare. --- nano/core_test/active_transactions.cpp | 1 + nano/core_test/bootstrap.cpp | 1 + nano/core_test/confirmation_height.cpp | 1 + nano/core_test/conflicts.cpp | 1 + nano/core_test/election.cpp | 1 + nano/core_test/election_scheduler.cpp | 1 + nano/core_test/frontiers_confirmation.cpp | 1 + nano/core_test/network.cpp | 1 + nano/core_test/node.cpp | 1 + nano/core_test/rep_crawler.cpp | 3 ++- nano/core_test/request_aggregator.cpp | 1 + nano/core_test/system.cpp | 1 + nano/core_test/vote_processor.cpp | 1 + nano/core_test/voting.cpp | 1 + nano/core_test/wallet.cpp | 1 + nano/core_test/wallets.cpp | 1 + nano/nano_node/entry.cpp | 1 + nano/node/active_transactions.cpp | 1 + nano/node/blockprocessor.cpp | 1 + nano/node/bootstrap/bootstrap_attempt.cpp | 1 + nano/node/bootstrap/bootstrap_bulk_pull.cpp | 1 + nano/node/bootstrap/bootstrap_frontier.cpp | 1 + nano/node/bootstrap/bootstrap_lazy.cpp | 1 + nano/node/cli.cpp | 1 + nano/node/election.cpp | 1 + nano/node/epoch_upgrader.cpp | 1 + nano/node/json_handler.cpp | 1 + nano/node/node.cpp | 4 +++- nano/node/node.hpp | 4 ++-- nano/node/repcrawler.cpp | 3 ++- nano/node/scheduler/hinted.cpp | 1 + nano/node/scheduler/optimistic.cpp | 1 + nano/node/scheduler/priority.cpp | 1 + nano/node/wallet.cpp | 1 + nano/qt/qt.cpp | 1 + nano/qt_test/qt.cpp | 1 + nano/rpc_test/receivable.cpp | 1 + nano/rpc_test/rpc.cpp | 1 + nano/slow_test/bootstrap.cpp | 1 + nano/slow_test/node.cpp | 1 + nano/test_common/system.cpp | 1 + nano/test_common/testutil.cpp | 1 + 42 files changed, 47 insertions(+), 5 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index c1f46b969f..e40e817015 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 57aeae26fc..34617b1d0a 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index db2e46fd0b..a150d40e44 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 65ff27d1fd..943bb75699 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index cd438074a2..766b41c069 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index b2af2740ba..c453bfe00e 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 9d476ed357..08967ce4a9 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 2e15d5ef9d..bf9ed2e651 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index b1bb5bf5ec..cf81a51bdb 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/rep_crawler.cpp b/nano/core_test/rep_crawler.cpp index 2c83b6c0f6..06d16b895d 100644 --- a/nano/core_test/rep_crawler.cpp +++ b/nano/core_test/rep_crawler.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -295,4 +296,4 @@ TEST (rep_crawler, two_reps_one_node) // check that the reps are correct ASSERT_TRUE (nano::dev::genesis_key.pub == reps[0].account || nano::dev::genesis_key.pub == reps[1].account); ASSERT_TRUE (second_rep.pub == reps[0].account || second_rep.pub == reps[1].account); -} \ No newline at end of file +} diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index f569c34941..7b1913f411 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 9fd8912483..ffd860180f 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 1da68596e8..100ec5c50b 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index cf210e3a1d..d6d644292e 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 0250f291d9..de2cfb42c0 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 606fa18f4f..af4b953b1f 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index a18d22af3c..97268e8849 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index d2df96e361..107e3df7cf 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index b9f8544d78..3bb23c8ee2 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index 390d502674..032cdd3b5e 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index d4b4e13215..a1fe5b8ec2 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 76fa692177..6380bd61a9 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 45e9cab61e..4646cbaa68 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 984f1656f4..449bb755a7 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include diff --git a/nano/node/election.cpp b/nano/node/election.cpp index d01d3718bd..9dda840329 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include diff --git a/nano/node/epoch_upgrader.cpp b/nano/node/epoch_upgrader.cpp index 48007b3559..58db6213d0 100644 --- a/nano/node/epoch_upgrader.cpp +++ b/nano/node/epoch_upgrader.cpp @@ -2,6 +2,7 @@ #include #include #include +#include nano::epoch_upgrader::epoch_upgrader (nano::node & node_a, nano::ledger & ledger_a, nano::store::component & store_a, nano::network_params & network_params_a, nano::logger & logger_a) : node{ node_a }, diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 2442a23c33..e8fb991469 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include diff --git a/nano/node/node.cpp b/nano/node/node.cpp index f6a9cdeed9..1845d4ac10 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include @@ -143,7 +144,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons unchecked{ config.max_unchecked_blocks, stats, flags.disable_block_processor_unchecked_deletion }, wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), wallets_store (*wallets_store_impl), - ledger (store, stats, network_params.ledger, flags_a.generate_cache), + ledger_impl{ std::make_unique (store, stats, network_params.ledger, flags_a.generate_cache) }, + ledger{ *ledger_impl }, outbound_limiter{ outbound_bandwidth_limiter_config (config) }, // empty `config.peering_port` means the user made no port choice at all; // otherwise, any value is considered, with `0` having the special meaning of 'let the OS pick a port instead' diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 4f52fdddfd..97127acf35 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -35,7 +35,6 @@ #include #include #include -#include #include #include @@ -151,7 +150,8 @@ class node final : public std::enable_shared_from_this nano::unchecked_map unchecked; std::unique_ptr wallets_store_impl; nano::wallets_store & wallets_store; - nano::ledger ledger; + std::unique_ptr ledger_impl; + nano::ledger & ledger; nano::outbound_bandwidth_limiter outbound_limiter; nano::network network; nano::telemetry telemetry; diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index ebe3e88104..adf2fd2fe1 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -1,5 +1,6 @@ #include #include +#include #include @@ -530,4 +531,4 @@ nano::error nano::rep_crawler_config::deserialize (nano::tomlconfig & toml) query_timeout = std::chrono::milliseconds{ query_timeout_l }; return toml.get_error (); -} \ No newline at end of file +} diff --git a/nano/node/scheduler/hinted.cpp b/nano/node/scheduler/hinted.cpp index aa423e74aa..33e008fa53 100644 --- a/nano/node/scheduler/hinted.cpp +++ b/nano/node/scheduler/hinted.cpp @@ -2,6 +2,7 @@ #include #include #include +#include /* * hinted diff --git a/nano/node/scheduler/optimistic.cpp b/nano/node/scheduler/optimistic.cpp index 8672d976e1..2c14251607 100644 --- a/nano/node/scheduler/optimistic.cpp +++ b/nano/node/scheduler/optimistic.cpp @@ -3,6 +3,7 @@ #include #include #include +#include nano::scheduler::optimistic::optimistic (optimistic_config const & config_a, nano::node & node_a, nano::ledger & ledger_a, nano::active_transactions & active_a, nano::network_constants const & network_constants_a, nano::stats & stats_a) : config{ config_a }, diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index 66d2008b35..3fbaafda39 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -2,6 +2,7 @@ #include #include #include +#include nano::scheduler::priority::priority (nano::node & node_a, nano::stats & stats_a) : node{ node_a }, diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index e155ecb6c9..6d7b6cd7a6 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 640080b557..b4d88c5799 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 313378e0fe..d6758ff883 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index d2659aac1d..e73221bd52 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 3e7f703466..7ca31f1649 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/slow_test/bootstrap.cpp b/nano/slow_test/bootstrap.cpp index 070da58f5a..6492ad6bd4 100644 --- a/nano/slow_test/bootstrap.cpp +++ b/nano/slow_test/bootstrap.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 0ac1ee294c..06b8728ebf 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 4d99cc904c..19a57c812c 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 271e73f665..ce80cfeae0 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include From 8dd0bf9603103b36edbbdf092d3f9ef517ec5e44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Sun, 10 Mar 2024 22:01:32 +0100 Subject: [PATCH 181/190] Dedicated `rep_tiers` class (#4471) * Vote processor tiers * Unused function cleanup * Use online weight for representative tier calculations * Simplify testcase * Dedicated `rep_tiers` class * Use trended stake * Fix test --- nano/core_test/vote_processor.cpp | 35 +++----- nano/lib/logging_enums.hpp | 1 + nano/lib/stats_enums.hpp | 4 + nano/lib/thread_roles.cpp | 3 + nano/lib/thread_roles.hpp | 1 + nano/node/CMakeLists.txt | 2 + nano/node/node.cpp | 20 ++--- nano/node/node.hpp | 3 +- nano/node/online_reps.hpp | 5 ++ nano/node/rep_tiers.cpp | 144 ++++++++++++++++++++++++++++++ nano/node/rep_tiers.hpp | 65 ++++++++++++++ nano/node/vote_processor.cpp | 78 ++++------------ nano/node/vote_processor.hpp | 17 ++-- 13 files changed, 268 insertions(+), 110 deletions(-) create mode 100644 nano/node/rep_tiers.cpp create mode 100644 nano/node/rep_tiers.hpp diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 100ec5c50b..f755eb8ac0 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -126,19 +126,17 @@ TEST (vote_processor, overflow) ASSERT_LT (std::chrono::system_clock::now () - start_time, 10s); } -namespace nano -{ TEST (vote_processor, weights) { nano::test::system system (4); auto & node (*system.nodes[0]); // Create representatives of different weight levels - // The online stake will be the minimum configurable due to online_reps sampling in tests - auto const online = node.config.online_weight_minimum.number (); - auto const level0 = online / 5000; // 0.02% - auto const level1 = online / 500; // 0.2% - auto const level2 = online / 50; // 2% + // FIXME: Using `online_weight_minimum` because calculation of trended and online weight is broken when running tests + auto const stake = node.config.online_weight_minimum.number (); + auto const level0 = stake / 5000; // 0.02% + auto const level1 = stake / 500; // 0.2% + auto const level2 = stake / 50; // 2% nano::keypair key0; nano::keypair key1; @@ -157,24 +155,15 @@ TEST (vote_processor, weights) // Wait for representatives ASSERT_TIMELY_EQ (10s, node.ledger.cache.rep_weights.get_rep_amounts ().size (), 4); - node.vote_processor.calculate_weights (); - - ASSERT_EQ (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (key0.pub)); - ASSERT_EQ (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (key0.pub)); - ASSERT_EQ (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (key0.pub)); - ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (key1.pub)); - ASSERT_EQ (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (key1.pub)); - ASSERT_EQ (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (key1.pub)); + // Wait for rep tiers to be updated + node.stats.clear (); + ASSERT_TIMELY (5s, node.stats.count (nano::stat::type::rep_tiers, nano::stat::detail::updated) >= 2); - ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (key2.pub)); - ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (key2.pub)); - ASSERT_EQ (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (key2.pub)); - - ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (nano::dev::genesis_key.pub)); - ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (nano::dev::genesis_key.pub)); - ASSERT_NE (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (nano::dev::genesis_key.pub)); -} + ASSERT_EQ (node.rep_tiers.tier (key0.pub), nano::rep_tier::none); + ASSERT_EQ (node.rep_tiers.tier (key1.pub), nano::rep_tier::tier_1); + ASSERT_EQ (node.rep_tiers.tier (key2.pub), nano::rep_tier::tier_2); + ASSERT_EQ (node.rep_tiers.tier (nano::dev::genesis_key.pub), nano::rep_tier::tier_3); } // Issue that tracks last changes on this test: https://github.com/nanocurrency/nano-node/issues/3485 diff --git a/nano/lib/logging_enums.hpp b/nano/lib/logging_enums.hpp index 41668e674e..eddf9b120a 100644 --- a/nano/lib/logging_enums.hpp +++ b/nano/lib/logging_enums.hpp @@ -71,6 +71,7 @@ enum class type vote_processor, election_scheduler, vote_generator, + rep_tiers, // bootstrap bulk_pull_client, diff --git a/nano/lib/stats_enums.hpp b/nano/lib/stats_enums.hpp index 6be28486eb..6d1ac20b29 100644 --- a/nano/lib/stats_enums.hpp +++ b/nano/lib/stats_enums.hpp @@ -51,6 +51,7 @@ enum class type : uint8_t handshake, rep_crawler, local_block_broadcaster, + rep_tiers, bootstrap_ascending, bootstrap_ascending_accounts, @@ -68,7 +69,10 @@ enum class detail : uint8_t loop, total, process, + processed, + ignored, update, + updated, request, broadcast, cleanup, diff --git a/nano/lib/thread_roles.cpp b/nano/lib/thread_roles.cpp index 969541edcb..944ac0e1bd 100644 --- a/nano/lib/thread_roles.cpp +++ b/nano/lib/thread_roles.cpp @@ -106,6 +106,9 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) case nano::thread_role::name::local_block_broadcasting: thread_role_name_string = "Local broadcast"; break; + case nano::thread_role::name::rep_tiers: + thread_role_name_string = "Rep tiers"; + break; default: debug_assert (false && "nano::thread_role::get_string unhandled thread role"); } diff --git a/nano/lib/thread_roles.hpp b/nano/lib/thread_roles.hpp index 80ed569f38..724efad5c8 100644 --- a/nano/lib/thread_roles.hpp +++ b/nano/lib/thread_roles.hpp @@ -44,6 +44,7 @@ enum class name scheduler_priority, rep_crawler, local_block_broadcasting, + rep_tiers, }; /* diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index d25585ff44..f8f3b5407e 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -126,6 +126,8 @@ add_library( process_live_dispatcher.hpp repcrawler.hpp repcrawler.cpp + rep_tiers.hpp + rep_tiers.cpp request_aggregator.hpp request_aggregator.cpp scheduler/bucket.cpp diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 1845d4ac10..8397fa70d3 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -165,7 +165,8 @@ nano::node::node (boost::asio::io_context & io_ctx_a, std::filesystem::path cons application_path (application_path_a), port_mapping (*this), rep_crawler (config.rep_crawler, *this), - vote_processor (active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params), + rep_tiers{ ledger, network_params, online_reps, stats, logger }, + vote_processor{ active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params, rep_tiers }, warmed_up (0), block_processor (*this, write_database_queue), online_reps (ledger, config), @@ -541,6 +542,7 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (node.ascendboot.collect_container_info ("bootstrap_ascending")); composite->add_component (node.unchecked.collect_container_info ("unchecked")); composite->add_component (node.local_block_broadcaster.collect_container_info ("local_block_broadcaster")); + composite->add_component (node.rep_tiers.collect_container_info ("rep_tiers")); return composite; } @@ -590,7 +592,6 @@ void nano::node::start () { rep_crawler.start (); } - ongoing_rep_calculation (); ongoing_peer_store (); ongoing_online_weight_calculation_queue (); @@ -636,6 +637,7 @@ void nano::node::start () port_mapping.start (); } wallets.start (); + rep_tiers.start (); vote_processor.start (); block_processor.start (); active.start (); @@ -676,6 +678,7 @@ void nano::node::stop () block_processor.stop (); aggregator.stop (); vote_processor.stop (); + rep_tiers.stop (); scheduler.stop (); active.stop (); generator.stop (); @@ -763,19 +766,6 @@ void nano::node::long_inactivity_cleanup () } } -void nano::node::ongoing_rep_calculation () -{ - auto now (std::chrono::steady_clock::now ()); - vote_processor.calculate_weights (); - std::weak_ptr node_w (shared_from_this ()); - workers.add_timed_task (now + std::chrono::minutes (10), [node_w] () { - if (auto node_l = node_w.lock ()) - { - node_l->ongoing_rep_calculation (); - } - }); -} - void nano::node::ongoing_bootstrap () { auto next_wakeup = network_params.network.bootstrap_interval; diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 97127acf35..65ad016ab1 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -92,7 +93,6 @@ class node final : public std::enable_shared_from_this std::pair balance_pending (nano::account const &, bool only_confirmed); nano::uint128_t weight (nano::account const &); nano::uint128_t minimum_principal_weight (); - void ongoing_rep_calculation (); void ongoing_bootstrap (); void ongoing_peer_store (); void backup_wallet (); @@ -163,6 +163,7 @@ class node final : public std::enable_shared_from_this nano::port_mapping port_mapping; nano::online_reps online_reps; nano::rep_crawler rep_crawler; + nano::rep_tiers rep_tiers; nano::vote_processor vote_processor; unsigned warmed_up; nano::block_processor block_processor; diff --git a/nano/node/online_reps.hpp b/nano/node/online_reps.hpp index 8b07e9a5d2..f01fec91e0 100644 --- a/nano/node/online_reps.hpp +++ b/nano/node/online_reps.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include @@ -15,6 +16,10 @@ namespace nano { class ledger; class node_config; +namespace store +{ + class transaction; +} /** Track online representatives and trend online weight */ class online_reps final diff --git a/nano/node/rep_tiers.cpp b/nano/node/rep_tiers.cpp new file mode 100644 index 0000000000..7b0cffb47d --- /dev/null +++ b/nano/node/rep_tiers.cpp @@ -0,0 +1,144 @@ +#include +#include +#include +#include +#include +#include + +using namespace std::chrono_literals; + +nano::rep_tiers::rep_tiers (nano::ledger & ledger_a, nano::network_params & network_params_a, nano::online_reps & online_reps_a, nano::stats & stats_a, nano::logger & logger_a) : + ledger{ ledger_a }, + network_params{ network_params_a }, + online_reps{ online_reps_a }, + stats{ stats_a }, + logger{ logger_a } +{ +} + +nano::rep_tiers::~rep_tiers () +{ + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); +} + +void nano::rep_tiers::start () +{ + debug_assert (!thread.joinable ()); + + thread = std::thread{ [this] () { + nano::thread_role::set (nano::thread_role::name::rep_tiers); + run (); + } }; +} + +void nano::rep_tiers::stop () +{ + { + nano::lock_guard lock{ mutex }; + stopped = true; + } + condition.notify_all (); + if (thread.joinable ()) + { + thread.join (); + } +} + +nano::rep_tier nano::rep_tiers::tier (const nano::account & representative) const +{ + nano::lock_guard lock{ mutex }; + if (representatives_3.find (representative) != representatives_3.end ()) + { + return nano::rep_tier::tier_3; + } + if (representatives_2.find (representative) != representatives_2.end ()) + { + return nano::rep_tier::tier_2; + } + if (representatives_1.find (representative) != representatives_1.end ()) + { + return nano::rep_tier::tier_1; + } + return nano::rep_tier::none; +} + +void nano::rep_tiers::run () +{ + nano::unique_lock lock{ mutex }; + while (!stopped) + { + stats.inc (nano::stat::type::rep_tiers, nano::stat::detail::loop); + + lock.unlock (); + + calculate_tiers (); + + lock.lock (); + + std::chrono::milliseconds interval = network_params.network.is_dev_network () ? 500ms : 10min; + condition.wait_for (lock, interval); + } +} + +void nano::rep_tiers::calculate_tiers () +{ + auto stake = online_reps.trended (); + auto rep_amounts = ledger.cache.rep_weights.get_rep_amounts (); + + decltype (representatives_1) representatives_1_l; + decltype (representatives_2) representatives_2_l; + decltype (representatives_3) representatives_3_l; + + int ignored = 0; + for (auto const & rep_amount : rep_amounts) + { + nano::account const & representative = rep_amount.first; + + // Using ledger weight here because it takes preconfigured bootstrap weights into account + auto weight = ledger.weight (representative); + if (weight > stake / 1000) // 0.1% or above (level 1) + { + representatives_1_l.insert (representative); + if (weight > stake / 100) // 1% or above (level 2) + { + representatives_2_l.insert (representative); + if (weight > stake / 20) // 5% or above (level 3) + { + representatives_3_l.insert (representative); + } + } + } + else + { + ++ignored; + } + } + + stats.add (nano::stat::type::rep_tiers, nano::stat::detail::processed, nano::stat::dir::in, rep_amounts.size ()); + stats.add (nano::stat::type::rep_tiers, nano::stat::detail::ignored, nano::stat::dir::in, ignored); + logger.debug (nano::log::type::rep_tiers, "Representative tiers updated, tier 1: {}, tier 2: {}, tier 3: {} ({} ignored)", + representatives_1_l.size (), + representatives_2_l.size (), + representatives_3_l.size (), + ignored); + + { + nano::lock_guard guard{ mutex }; + representatives_1 = std::move (representatives_1_l); + representatives_2 = std::move (representatives_2_l); + representatives_3 = std::move (representatives_3_l); + } + + stats.inc (nano::stat::type::rep_tiers, nano::stat::detail::updated); +} + +std::unique_ptr nano::rep_tiers::collect_container_info (const std::string & name) +{ + nano::lock_guard lock{ mutex }; + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (container_info{ "representatives_1", representatives_1.size (), sizeof (decltype (representatives_1)::value_type) })); + composite->add_component (std::make_unique (container_info{ "representatives_2", representatives_2.size (), sizeof (decltype (representatives_2)::value_type) })); + composite->add_component (std::make_unique (container_info{ "representatives_3", representatives_3.size (), sizeof (decltype (representatives_3)::value_type) })); + return composite; +} \ No newline at end of file diff --git a/nano/node/rep_tiers.hpp b/nano/node/rep_tiers.hpp new file mode 100644 index 0000000000..ce989d8e0a --- /dev/null +++ b/nano/node/rep_tiers.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include + +namespace nano +{ +class ledger; +class network_params; +class stats; +class logger; +class container_info_component; +class online_reps; + +// Higher number means higher priority +enum class rep_tier +{ + none, // Not a principal representatives + tier_1, // (0.1-1%) of online stake + tier_2, // (1-5%) of online stake + tier_3, // (> 5%) of online stake +}; + +class rep_tiers final +{ +public: + rep_tiers (nano::ledger &, nano::network_params &, nano::online_reps &, nano::stats &, nano::logger &); + ~rep_tiers (); + + void start (); + void stop (); + + /** Returns the representative tier for the account */ + nano::rep_tier tier (nano::account const & representative) const; + + std::unique_ptr collect_container_info (std::string const & name); + +private: // Dependencies + nano::ledger & ledger; + nano::network_params & network_params; + nano::online_reps & online_reps; + nano::stats & stats; + nano::logger & logger; + +private: + void run (); + void calculate_tiers (); + +private: + /** Representatives levels for early prioritization */ + std::unordered_set representatives_1; + std::unordered_set representatives_2; + std::unordered_set representatives_3; + + std::atomic stopped{ false }; + nano::condition_variable condition; + mutable nano::mutex mutex; + std::thread thread; +}; +} \ No newline at end of file diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 9c094abf45..337b0bddfb 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -15,17 +16,18 @@ using namespace std::chrono_literals; -nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : - active (active_a), - observers (observers_a), - stats (stats_a), - config (config_a), - logger (logger_a), - online_reps (online_reps_a), - rep_crawler (rep_crawler_a), - ledger (ledger_a), - network_params (network_params_a), - max_votes (flags_a.vote_processor_capacity) +nano::vote_processor::vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a, nano::rep_tiers & rep_tiers_a) : + active{ active_a }, + observers{ observers_a }, + stats{ stats_a }, + config{ config_a }, + logger{ logger_a }, + online_reps{ online_reps_a }, + rep_crawler{ rep_crawler_a }, + ledger{ ledger_a }, + network_params{ network_params_a }, + rep_tiers{ rep_tiers_a }, + max_votes{ flags_a.vote_processor_capacity } { } @@ -111,6 +113,8 @@ bool nano::vote_processor::vote (std::shared_ptr const & vote_a, std nano::unique_lock lock{ mutex }; if (!stopped) { + auto tier = rep_tiers.tier (vote_a->account); + // Level 0 (< 0.1%) if (votes.size () < 6.0 / 9.0 * max_votes) { @@ -119,17 +123,17 @@ bool nano::vote_processor::vote (std::shared_ptr const & vote_a, std // Level 1 (0.1-1%) else if (votes.size () < 7.0 / 9.0 * max_votes) { - process = (representatives_1.find (vote_a->account) != representatives_1.end ()); + process = (tier == nano::rep_tier::tier_1); } // Level 2 (1-5%) else if (votes.size () < 8.0 / 9.0 * max_votes) { - process = (representatives_2.find (vote_a->account) != representatives_2.end ()); + process = (tier == nano::rep_tier::tier_2); } // Level 3 (> 5%) else if (votes.size () < max_votes) { - process = (representatives_3.find (vote_a->account) != representatives_3.end ()); + process = (tier == nano::rep_tier::tier_3); } if (process) { @@ -219,60 +223,14 @@ bool nano::vote_processor::empty () const return votes.empty (); } -bool nano::vote_processor::half_full () const -{ - return size () >= max_votes / 2; -} - -void nano::vote_processor::calculate_weights () -{ - nano::unique_lock lock{ mutex }; - if (!stopped) - { - representatives_1.clear (); - representatives_2.clear (); - representatives_3.clear (); - auto supply (online_reps.trended ()); - auto rep_amounts = ledger.cache.rep_weights.get_rep_amounts (); - for (auto const & rep_amount : rep_amounts) - { - nano::account const & representative (rep_amount.first); - auto weight (ledger.weight (representative)); - if (weight > supply / 1000) // 0.1% or above (level 1) - { - representatives_1.insert (representative); - if (weight > supply / 100) // 1% or above (level 2) - { - representatives_2.insert (representative); - if (weight > supply / 20) // 5% or above (level 3) - { - representatives_3.insert (representative); - } - } - } - } - } -} - std::unique_ptr nano::collect_container_info (vote_processor & vote_processor, std::string const & name) { std::size_t votes_count; - std::size_t representatives_1_count; - std::size_t representatives_2_count; - std::size_t representatives_3_count; - { nano::lock_guard guard{ vote_processor.mutex }; votes_count = vote_processor.votes.size (); - representatives_1_count = vote_processor.representatives_1.size (); - representatives_2_count = vote_processor.representatives_2.size (); - representatives_3_count = vote_processor.representatives_3.size (); } - auto composite = std::make_unique (name); composite->add_component (std::make_unique (container_info{ "votes", votes_count, sizeof (decltype (vote_processor.votes)::value_type) })); - composite->add_component (std::make_unique (container_info{ "representatives_1", representatives_1_count, sizeof (decltype (vote_processor.representatives_1)::value_type) })); - composite->add_component (std::make_unique (container_info{ "representatives_2", representatives_2_count, sizeof (decltype (vote_processor.representatives_2)::value_type) })); - composite->add_component (std::make_unique (container_info{ "representatives_3", representatives_3_count, sizeof (decltype (vote_processor.representatives_3)::value_type) })); return composite; } diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index 4591c5ee71..b7498180fc 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -11,7 +11,6 @@ namespace nano { -class signature_checker; class active_transactions; namespace store { @@ -27,6 +26,7 @@ class ledger; class network_params; class node_flags; class stats; +class rep_tiers; namespace transport { @@ -36,7 +36,7 @@ namespace transport class vote_processor final { public: - vote_processor (nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stats & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger &, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a); + vote_processor (nano::active_transactions &, nano::node_observers &, nano::stats &, nano::node_config &, nano::node_flags &, nano::logger &, nano::online_reps &, nano::rep_crawler &, nano::ledger &, nano::network_params &, nano::rep_tiers &); ~vote_processor (); void start (); @@ -46,14 +46,12 @@ class vote_processor final bool vote (std::shared_ptr const &, std::shared_ptr const &); /** Note: node.active.mutex lock is required */ nano::vote_code vote_blocking (std::shared_ptr const &, std::shared_ptr const &, bool = false); - void verify_votes (std::deque, std::shared_ptr>> const &); + /** Function blocks until either the current queue size (a established flush boundary as it'll continue to increase) * is processed or the queue is empty (end condition or cutoff's guard, as it is positioned ahead) */ void flush (); std::size_t size () const; bool empty () const; - bool half_full () const; - void calculate_weights (); std::atomic total_processed{ 0 }; @@ -67,18 +65,16 @@ class vote_processor final nano::rep_crawler & rep_crawler; nano::ledger & ledger; nano::network_params & network_params; + nano::rep_tiers & rep_tiers; private: void run (); + void verify_votes (std::deque, std::shared_ptr>> const &); +private: std::size_t const max_votes; std::deque, std::shared_ptr>> votes; - /** Representatives levels for random early detection */ - std::unordered_set representatives_1; - std::unordered_set representatives_2; - std::unordered_set representatives_3; - private: bool stopped{ false }; nano::condition_variable condition; @@ -86,7 +82,6 @@ class vote_processor final std::thread thread; friend std::unique_ptr collect_container_info (vote_processor & vote_processor, std::string const & name); - friend class vote_processor_weights_Test; }; std::unique_ptr collect_container_info (vote_processor & vote_processor, std::string const & name); From d59565539206158076ab043042b1f8e86cb0e2c9 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Mon, 11 Mar 2024 13:52:29 +0100 Subject: [PATCH 182/190] Multithreaded request aggregator (#4469) * Run aggregator threaded * Configurable number of aggregator threads * Default to max 4 threads * Added unit test for request_aggregator_threads toml * Improve the description of request_aggregator_threads --------- Co-authored-by: Dimitrios Siganos --- nano/core_test/toml.cpp | 3 +++ nano/node/nodeconfig.cpp | 2 ++ nano/node/nodeconfig.hpp | 1 + nano/node/request_aggregator.cpp | 16 ++++++++++++---- nano/node/request_aggregator.hpp | 4 +++- 5 files changed, 21 insertions(+), 5 deletions(-) diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index 4e13e7b422..9e2a5cbe83 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -193,6 +193,7 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.work_peers, defaults.node.work_peers); ASSERT_EQ (conf.node.work_threads, defaults.node.work_threads); ASSERT_EQ (conf.node.max_queued_requests, defaults.node.max_queued_requests); + ASSERT_EQ (conf.node.request_aggregator_threads, defaults.node.request_aggregator_threads); ASSERT_EQ (conf.node.max_unchecked_blocks, defaults.node.max_unchecked_blocks); ASSERT_EQ (conf.node.backlog_scan_batch_size, defaults.node.backlog_scan_batch_size); ASSERT_EQ (conf.node.backlog_scan_frequency, defaults.node.backlog_scan_frequency); @@ -422,6 +423,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) work_threads = 999 max_work_generate_multiplier = 1.0 max_queued_requests = 999 + request_aggregator_threads = 999 max_unchecked_blocks = 999 frontiers_confirmation = "always" backlog_scan_batch_size = 999 @@ -613,6 +615,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.work_peers, defaults.node.work_peers); ASSERT_NE (conf.node.work_threads, defaults.node.work_threads); ASSERT_NE (conf.node.max_queued_requests, defaults.node.max_queued_requests); + ASSERT_NE (conf.node.request_aggregator_threads, defaults.node.request_aggregator_threads); ASSERT_NE (conf.node.backlog_scan_batch_size, defaults.node.backlog_scan_batch_size); ASSERT_NE (conf.node.backlog_scan_frequency, defaults.node.backlog_scan_frequency); diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index 2d7e23ab44..e5b2cad9fb 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -130,6 +130,7 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const toml.put ("max_work_generate_multiplier", max_work_generate_multiplier, "Maximum allowed difficulty multiplier for work generation.\ntype:double,[1..]"); toml.put ("frontiers_confirmation", serialize_frontiers_confirmation (frontiers_confirmation), "Mode controlling frontier confirmation rate.\ntype:string,{auto,always,disabled}"); toml.put ("max_queued_requests", max_queued_requests, "Limit for number of queued confirmation requests for one channel, after which new requests are dropped until the queue drops below this value.\ntype:uint32"); + toml.put ("request_aggregator_threads", request_aggregator_threads, "Number of threads to dedicate to request aggregator. The default value is the minimum of 4 or the number returned by nano::hardware_concurency(), which is the number of hardware threads or the value of the environment variable NANO_HARDWARE_CONCURRENCY."); toml.put ("max_unchecked_blocks", max_unchecked_blocks, "Maximum number of unchecked blocks to store in memory. Defaults to 65536. \ntype:uint64,[0..]"); toml.put ("rep_crawler_weight_minimum", rep_crawler_weight_minimum.to_string_dec (), "Rep crawler minimum weight, if this is less than minimum principal weight then this is taken as the minimum weight a rep must have to be tracked. If you want to track all reps set this to 0. If you do not want this to influence anything then set it to max value. This is only useful for debugging or for people who really know what they are doing.\ntype:string,amount,raw"); toml.put ("backlog_scan_batch_size", backlog_scan_batch_size, "Number of accounts per second to process when doing backlog population scan. Increasing this value will help unconfirmed frontiers get into election prioritization queue faster, however it will also increase resource usage. \ntype:uint"); @@ -427,6 +428,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) toml.get ("max_work_generate_multiplier", max_work_generate_multiplier); toml.get ("max_queued_requests", max_queued_requests); + toml.get ("request_aggregator_threads", request_aggregator_threads); toml.get ("max_unchecked_blocks", max_unchecked_blocks); diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 252f6e07fb..cf778df4ee 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -118,6 +118,7 @@ class node_config bool backup_before_upgrade{ false }; double max_work_generate_multiplier{ 64. }; uint32_t max_queued_requests{ 512 }; + unsigned request_aggregator_threads{ std::min (nano::hardware_concurrency (), 4u) }; // Max 4 threads if available unsigned max_unchecked_blocks{ 65536 }; std::chrono::seconds max_pruning_age{ !network_params.network.is_beta_network () ? std::chrono::seconds (24 * 60 * 60) : std::chrono::seconds (5 * 60) }; // 1 day; 5 minutes for beta network uint64_t max_pruning_depth{ 0 }; diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index 0e61195e87..72a5e3e405 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -15,15 +15,20 @@ nano::request_aggregator::request_aggregator (nano::node_config const & config_a max_delay (config_a.network_params.network.is_dev_network () ? 50 : 300), small_delay (config_a.network_params.network.is_dev_network () ? 10 : 50), max_channel_requests (config_a.max_queued_requests), + request_aggregator_threads (config_a.request_aggregator_threads), stats (stats_a), local_votes (history_a), ledger (ledger_a), wallets (wallets_a), active (active_a), generator (generator_a), - final_generator (final_generator_a), - thread ([this] () { run (); }) + final_generator (final_generator_a) { + for (auto i = 0; i < request_aggregator_threads; ++i) + { + threads.emplace_back ([this] () { run (); }); + } + generator.set_reply_action ([this] (std::shared_ptr const & vote_a, std::shared_ptr const & channel_a) { this->reply_action (vote_a, channel_a); }); @@ -132,9 +137,12 @@ void nano::request_aggregator::stop () stopped = true; } condition.notify_all (); - if (thread.joinable ()) + for (auto & thread : threads) { - thread.join (); + if (thread.joinable ()) + { + thread.join (); + } } } diff --git a/nano/node/request_aggregator.hpp b/nano/node/request_aggregator.hpp index 657b7b56f3..f88a6b4faa 100644 --- a/nano/node/request_aggregator.hpp +++ b/nano/node/request_aggregator.hpp @@ -13,6 +13,7 @@ #include #include #include +#include namespace mi = boost::multi_index; @@ -74,6 +75,7 @@ class request_aggregator final std::chrono::milliseconds const max_delay; std::chrono::milliseconds const small_delay; std::size_t const max_channel_requests; + std::size_t const request_aggregator_threads; private: void run (); @@ -105,7 +107,7 @@ class request_aggregator final bool started{ false }; nano::condition_variable condition; nano::mutex mutex{ mutex_identifier (mutexes::request_aggregator) }; - std::thread thread; + std::vector threads; friend std::unique_ptr collect_container_info (request_aggregator &, std::string const &); }; From 47e7c811680f5ea1332e19ad1fc7ed01f838ad0d Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 11 Mar 2024 21:09:46 +0000 Subject: [PATCH 183/190] Remove ledger::block_destination and use block::destination (#4478) --- nano/core_test/ledger.cpp | 12 ++++++------ nano/node/active_transactions.cpp | 5 ++--- nano/node/json_handler.cpp | 14 ++++++-------- nano/qt/qt.cpp | 4 ++-- nano/secure/ledger.cpp | 16 ---------------- nano/secure/ledger.hpp | 1 - 6 files changed, 16 insertions(+), 36 deletions(-) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index a08eb2422c..28d2b323b6 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2328,17 +2328,17 @@ TEST (ledger, block_destination_source) ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block5)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); - ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); + ASSERT_EQ (dest.pub, block1->destination ()); ASSERT_FALSE (block1->source_field ()); - ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block2)); + ASSERT_EQ (nano::dev::genesis_key.pub, block2->destination ()); ASSERT_FALSE (block2->source_field ()); - ASSERT_EQ (ledger.block_destination (transaction, *block3), nullptr); + ASSERT_FALSE (block3->destination_field ()); ASSERT_EQ (block2->hash (), block3->source ()); - ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block4)); + ASSERT_EQ (dest.pub, block4->destination ()); ASSERT_FALSE (block4->source_field ()); - ASSERT_EQ (nano::dev::genesis_key.pub, ledger.block_destination (transaction, *block5)); + ASSERT_EQ (nano::dev::genesis_key.pub, block5->destination ()); ASSERT_FALSE (block5->source_field ()); - ASSERT_EQ (ledger.block_destination (transaction, *block6), nullptr); + ASSERT_FALSE (block6->destination_field ()); ASSERT_EQ (block5->hash (), block6->source ()); } diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 107e3df7cf..be79107759 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -213,12 +213,11 @@ void nano::active_transactions::handle_final_votes_confirmation (std::shared_ptr void nano::active_transactions::activate_successors (const nano::account & account, std::shared_ptr const & block, nano::store::read_transaction const & transaction) { node.scheduler.priority.activate (account, transaction); - auto const & destination = node.ledger.block_destination (transaction, *block); // Start or vote for the next unconfirmed block in the destination account - if (!destination.is_zero () && destination != account) + if (block->is_send () && !block->destination ().is_zero () && block->destination () != account) { - node.scheduler.priority.activate (destination, transaction); + node.scheduler.priority.activate (block->destination (), transaction); } } diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index e8fb991469..27e7c92f12 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1342,8 +1342,7 @@ void nano::json_handler::blocks_info () } if (receivable || receive_hash) { - auto destination (node.ledger.block_destination (transaction, *block)); - if (destination.is_zero ()) + if (!block->is_send ()) { if (receivable) { @@ -1355,7 +1354,7 @@ void nano::json_handler::blocks_info () entry.put ("receive_hash", nano::block_hash (0).to_string ()); } } - else if (node.store.pending.exists (transaction, nano::pending_key (destination, hash))) + else if (node.store.pending.exists (transaction, nano::pending_key (block->destination (), hash))) { if (receivable) { @@ -1376,7 +1375,7 @@ void nano::json_handler::blocks_info () } if (receive_hash) { - std::shared_ptr receive_block = node.ledger.find_receive_block_by_send_hash (transaction, destination, hash); + std::shared_ptr receive_block = node.ledger.find_receive_block_by_send_hash (transaction, block->destination (), hash); std::string receive_hash = receive_block ? receive_block->hash ().to_string () : nano::block_hash (0).to_string (); entry.put ("receive_hash", receive_hash); } @@ -3163,10 +3162,9 @@ void nano::json_handler::receivable_exists () if (block != nullptr) { auto exists (false); - auto destination (node.ledger.block_destination (transaction, *block)); - if (!destination.is_zero ()) + if (block->is_send ()) { - exists = node.store.pending.exists (transaction, nano::pending_key (destination, hash)); + exists = node.store.pending.exists (transaction, nano::pending_key (block->destination (), hash)); } exists = exists && (block_confirmed (node, transaction, block->hash (), include_active, include_only_confirmed)); response_l.put ("exists", exists ? "1" : "0"); @@ -3668,7 +3666,7 @@ void nano::json_handler::republish () if (destinations != 0) // Republish destination chain { auto block_b = node.ledger.block (transaction, hash); - auto destination (node.ledger.block_destination (transaction, *block_b)); + auto destination = block_b->destination (); if (!destination.is_zero ()) { if (!node.store.pending.exists (transaction, nano::pending_key (destination, hash))) diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index b4d88c5799..7c0cd58746 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -2318,7 +2318,7 @@ void nano_qt::block_creation::create_receive () auto block_l (wallet.node.ledger.block (block_transaction, source_l)); if (block_l != nullptr) { - auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); + auto destination = block_l->destination (); if (!destination.is_zero ()) { nano::pending_key pending_key (destination, source_l); @@ -2483,7 +2483,7 @@ void nano_qt::block_creation::create_open () auto block_l (wallet.node.ledger.block (block_transaction, source_l)); if (block_l != nullptr) { - auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); + auto destination = block_l->destination (); if (!destination.is_zero ()) { nano::pending_key pending_key (destination, source_l); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index ca6ec8b2f2..b159371005 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -950,22 +950,6 @@ std::string nano::ledger::block_text (nano::block_hash const & hash_a) return result; } -nano::account const & nano::ledger::block_destination (store::transaction const & transaction_a, nano::block const & block_a) -{ - nano::send_block const * send_block (dynamic_cast (&block_a)); - nano::state_block const * state_block (dynamic_cast (&block_a)); - if (send_block != nullptr) - { - return send_block->hashables.destination; - } - else if (state_block != nullptr && block_a.is_send ()) - { - return state_block->hashables.link.as_account (); - } - - return nano::account::null (); -} - std::pair nano::ledger::hash_root_random (store::transaction const & transaction_a) const { nano::block_hash hash (0); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 864902a826..084923ade6 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -64,7 +64,6 @@ class ledger final bool root_exists (store::transaction const &, nano::root const &); std::string block_text (char const *); std::string block_text (nano::block_hash const &); - nano::account const & block_destination (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; nano::block_status process (store::write_transaction const & transaction, std::shared_ptr block); From c58ff456b7190cd615656338408bde257e2434ab Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 11 Mar 2024 23:31:54 +0000 Subject: [PATCH 184/190] Remove pragma from pending_info.cpp (#4480) --- nano/secure/pending_info.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/nano/secure/pending_info.cpp b/nano/secure/pending_info.cpp index 2989239f1f..24aa14b3ad 100644 --- a/nano/secure/pending_info.cpp +++ b/nano/secure/pending_info.cpp @@ -1,5 +1,3 @@ -#pragma once - #include nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) : From 623a1354f169ef94499d39f8de7398eee2c835a6 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 12 Mar 2024 09:08:02 +0000 Subject: [PATCH 185/190] Remove unused function ledger::root_exists (#4481) --- nano/secure/ledger.cpp | 5 ----- nano/secure/ledger.hpp | 1 - 2 files changed, 6 deletions(-) diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index b159371005..142d68df9d 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -928,11 +928,6 @@ bool nano::ledger::block_or_pruned_exists (store::transaction const & transactio return block_exists (transaction_a, hash_a); } -bool nano::ledger::root_exists (store::transaction const & transaction_a, nano::root const & root_a) -{ - return block_exists (transaction_a, root_a.as_block_hash ()) || store.account.exists (transaction_a, root_a.as_account ()); -} - std::string nano::ledger::block_text (char const * hash_a) { return block_text (nano::block_hash (hash_a)); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 084923ade6..cf6e6515be 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -61,7 +61,6 @@ class ledger final nano::block_hash representative_calculated (store::transaction const &, nano::block_hash const &); bool block_or_pruned_exists (nano::block_hash const &) const; bool block_or_pruned_exists (store::transaction const &, nano::block_hash const &) const; - bool root_exists (store::transaction const &, nano::root const &); std::string block_text (char const *); std::string block_text (nano::block_hash const &); std::pair hash_root_random (store::transaction const &) const; From 751553710b364843f021b26420f422daff0c676d Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 12 Mar 2024 09:08:31 +0000 Subject: [PATCH 186/190] Convert store::pending::get to return an optional rather than using an out-argument and returning an error code. (#4479) --- nano/core_test/block_store.cpp | 10 +++---- nano/core_test/ledger.cpp | 3 +- nano/qt/qt.cpp | 14 ++++------ nano/secure/ledger.cpp | 50 ++++++++++++++++------------------ nano/store/lmdb/pending.cpp | 8 ++++-- nano/store/lmdb/pending.hpp | 2 +- nano/store/pending.hpp | 3 +- nano/store/rocksdb/pending.cpp | 8 ++++-- nano/store/rocksdb/pending.hpp | 2 +- 9 files changed, 49 insertions(+), 51 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 08e267716f..07ca6d9b08 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -295,15 +295,15 @@ TEST (block_store, add_pending) ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::pending_key key2 (0, 0); - nano::pending_info pending1; auto transaction (store->tx_begin_write ()); - ASSERT_TRUE (store->pending.get (transaction, key2, pending1)); + ASSERT_FALSE (store->pending.get (transaction, key2)); + nano::pending_info pending1; store->pending.put (transaction, key2, pending1); - nano::pending_info pending2; - ASSERT_FALSE (store->pending.get (transaction, key2, pending2)); + std::optional pending2; + ASSERT_TRUE (pending2 = store->pending.get (transaction, key2)); ASSERT_EQ (pending1, pending2); store->pending.del (transaction, key2); - ASSERT_TRUE (store->pending.get (transaction, key2, pending2)); + ASSERT_FALSE (store->pending.get (transaction, key2)); } TEST (block_store, pending_iterator) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 28d2b323b6..f74d115a62 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -5481,8 +5481,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) nano::store::rocksdb::component rocksdb_store{ logger, path / "rocksdb", nano::dev::constants }; auto rocksdb_transaction (rocksdb_store.tx_begin_read ()); - nano::pending_info pending_info{}; - ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis_key.pub, send->hash ()), pending_info)); + ASSERT_TRUE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis_key.pub, send->hash ()))); for (auto i = rocksdb_store.online_weight.begin (rocksdb_transaction); i != rocksdb_store.online_weight.end (); ++i) { diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 7c0cd58746..2b07123e27 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -2322,8 +2322,7 @@ void nano_qt::block_creation::create_receive () if (!destination.is_zero ()) { nano::pending_key pending_key (destination, source_l); - nano::pending_info pending; - if (!wallet.node.store.pending.get (block_transaction, pending_key, pending)) + if (auto pending = wallet.node.store.pending.get (block_transaction, pending_key)) { nano::account_info info; auto error (wallet.node.store.account.get (block_transaction, pending_key.account, info)); @@ -2333,10 +2332,10 @@ void nano_qt::block_creation::create_receive () auto error (wallet.wallet_m->store.fetch (transaction, pending_key.account, key)); if (!error) { - nano::state_block receive (pending_key.account, info.head, info.representative, info.balance.number () + pending.amount.number (), source_l, key, pending_key.account, 0); + nano::state_block receive (pending_key.account, info.head, info.representative, info.balance.number () + pending.value ().amount.number (), source_l, key, pending_key.account, 0); nano::block_details details; details.is_receive = true; - details.epoch = std::max (info.epoch (), pending.epoch); + details.epoch = std::max (info.epoch (), pending.value ().epoch); auto required_difficulty{ wallet.node.network_params.work.threshold (receive.work_version (), details) }; if (wallet.node.work_generate_blocking (receive, required_difficulty).has_value ()) { @@ -2487,8 +2486,7 @@ void nano_qt::block_creation::create_open () if (!destination.is_zero ()) { nano::pending_key pending_key (destination, source_l); - nano::pending_info pending; - if (!wallet.node.store.pending.get (block_transaction, pending_key, pending)) + if (auto pending = wallet.node.store.pending.get (block_transaction, pending_key)) { nano::account_info info; auto error (wallet.node.store.account.get (block_transaction, pending_key.account, info)); @@ -2498,10 +2496,10 @@ void nano_qt::block_creation::create_open () auto error (wallet.wallet_m->store.fetch (transaction, pending_key.account, key)); if (!error) { - nano::state_block open (pending_key.account, 0, representative_l, pending.amount, source_l, key, pending_key.account, 0); + nano::state_block open (pending_key.account, 0, representative_l, pending.value ().amount, source_l, key, pending_key.account, 0); nano::block_details details; details.is_receive = true; - details.epoch = pending.epoch; + details.epoch = pending.value ().epoch; auto const required_difficulty{ wallet.node.network_params.work.threshold (open.work_version (), details) }; if (wallet.node.work_generate_blocking (open, required_difficulty).has_value ()) { diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 142d68df9d..e317652891 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -39,23 +39,24 @@ class rollback_visitor : public nano::block_visitor void send_block (nano::send_block const & block_a) override { auto hash (block_a.hash ()); - nano::pending_info pending; nano::pending_key key (block_a.hashables.destination, hash); - while (!error && ledger.store.pending.get (transaction, key, pending)) + auto pending = ledger.store.pending.get (transaction, key); + while (!error && !pending.has_value ()) { error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination), list); + pending = ledger.store.pending.get (transaction, key); } if (!error) { - auto info = ledger.account_info (transaction, pending.source); + auto info = ledger.account_info (transaction, pending.value ().source); debug_assert (info); ledger.store.pending.del (transaction, key); - ledger.cache.rep_weights.representation_add (info->representative, pending.amount.number ()); + ledger.cache.rep_weights.representation_add (info->representative, pending.value ().amount.number ()); nano::account_info new_info (block_a.hashables.previous, info->representative, info->open_block, ledger.balance (transaction, block_a.hashables.previous).value (), nano::seconds_since_epoch (), info->block_count - 1, nano::epoch::epoch_0); - ledger.update_account (transaction, pending.source, *info, new_info); + ledger.update_account (transaction, pending.value ().source, *info, new_info); ledger.store.block.del (transaction, hash); ledger.store.frontier.del (transaction, hash); - ledger.store.frontier.put (transaction, block_a.hashables.previous, pending.source); + ledger.store.frontier.put (transaction, block_a.hashables.previous, pending.value ().source); ledger.store.block.successor_clear (transaction, block_a.hashables.previous); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send); } @@ -315,12 +316,12 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) if (result == nano::block_status::progress) { nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()); - nano::pending_info pending; - result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + auto pending = ledger.store.pending.get (transaction, key); + result = !pending ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) if (result == nano::block_status::progress) { - result = amount == pending.amount ? nano::block_status::progress : nano::block_status::balance_mismatch; - source_epoch = pending.epoch; + result = amount == pending.value ().amount ? nano::block_status::progress : nano::block_status::balance_mismatch; + source_epoch = pending.value ().epoch; epoch = std::max (epoch, source_epoch); } } @@ -577,18 +578,18 @@ void ledger_processor::receive_block (nano::receive_block & block_a) if (result == nano::block_status::progress) { nano::pending_key key (account, block_a.hashables.source); - nano::pending_info pending; - result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + auto pending = ledger.store.pending.get (transaction, key); + result = !pending ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) if (result == nano::block_status::progress) { - result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) + result = pending.value ().epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed) if (result == nano::block_status::progress) { - auto new_balance (info->balance.number () + pending.amount.number ()); + auto new_balance (info->balance.number () + pending.value ().amount.number ()); #ifdef NDEBUG if (ledger.store.block.exists (transaction, block_a.hashables.source)) { @@ -601,7 +602,7 @@ void ledger_processor::receive_block (nano::receive_block & block_a) ledger.store.block.put (transaction, hash, block_a); nano::account_info new_info (hash, info->representative, info->open_block, new_balance, nano::seconds_since_epoch (), info->block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, *info, new_info); - ledger.cache.rep_weights.representation_add (info->representative, pending.amount.number ()); + ledger.cache.rep_weights.representation_add (info->representative, pending.value ().amount.number ()); ledger.store.frontier.del (transaction, block_a.hashables.previous); ledger.store.frontier.put (transaction, hash, account); ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive); @@ -640,14 +641,14 @@ void ledger_processor::open_block (nano::open_block & block_a) if (result == nano::block_status::progress) { nano::pending_key key (block_a.hashables.account, block_a.hashables.source); - nano::pending_info pending; - result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) + auto pending = ledger.store.pending.get (transaction, key); + result = !pending ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed) if (result == nano::block_status::progress) { result = block_a.hashables.account == ledger.constants.burn_account ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is it burning 0 account? (Malicious) if (result == nano::block_status::progress) { - result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) + result = pending.value ().epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed) if (result == nano::block_status::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); @@ -663,11 +664,11 @@ void ledger_processor::open_block (nano::open_block & block_a) } #endif ledger.store.pending.del (transaction, key); - block_a.sideband_set (nano::block_sideband (block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); + block_a.sideband_set (nano::block_sideband (block_a.hashables.account, 0, pending.value ().amount, 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); ledger.store.block.put (transaction, hash, block_a); - nano::account_info new_info (hash, block_a.representative_field ().value (), hash, pending.amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0); + nano::account_info new_info (hash, block_a.representative_field ().value (), hash, pending.value ().amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0); ledger.update_account (transaction, block_a.hashables.account, info, new_info); - ledger.cache.rep_weights.representation_add (block_a.representative_field ().value (), pending.amount.number ()); + ledger.cache.rep_weights.representation_add (block_a.representative_field ().value (), pending.value ().amount.number ()); ledger.store.frontier.put (transaction, hash, block_a.hashables.account); ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open); } @@ -880,12 +881,7 @@ nano::uint128_t nano::ledger::account_receivable (store::transaction const & tra std::optional nano::ledger::pending_info (store::transaction const & transaction, nano::pending_key const & key) const { - nano::pending_info result; - if (!store.pending.get (transaction, key, result)) - { - return result; - } - return std::nullopt; + return store.pending.get (transaction, key); } nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, std::shared_ptr block_a) diff --git a/nano/store/lmdb/pending.cpp b/nano/store/lmdb/pending.cpp index 961b201829..cabb70896b 100644 --- a/nano/store/lmdb/pending.cpp +++ b/nano/store/lmdb/pending.cpp @@ -17,16 +17,18 @@ void nano::store::lmdb::pending::del (store::write_transaction const & transacti store.release_assert_success (status); } -bool nano::store::lmdb::pending::get (store::transaction const & transaction, nano::pending_key const & key, nano::pending_info & pending_a) +std::optional nano::store::lmdb::pending::get (store::transaction const & transaction, nano::pending_key const & key) { nano::store::lmdb::db_val value; auto status1 = store.get (transaction, tables::pending, key, value); release_assert (store.success (status1) || store.not_found (status1)); - bool result (true); + std::optional result; if (store.success (status1)) { nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = pending_a.deserialize (stream); + result = nano::pending_info{}; + auto error = result.value ().deserialize (stream); + release_assert (!error); } return result; } diff --git a/nano/store/lmdb/pending.hpp b/nano/store/lmdb/pending.hpp index 1c110fa186..13cd9172d2 100644 --- a/nano/store/lmdb/pending.hpp +++ b/nano/store/lmdb/pending.hpp @@ -19,7 +19,7 @@ class pending : public nano::store::pending explicit pending (nano::store::lmdb::component & store_a); void put (store::write_transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info const & pending_info_a) override; void del (store::write_transaction const & transaction_a, nano::pending_key const & key_a) override; - bool get (store::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info & pending_a) override; + std::optional get (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool any (store::transaction const & transaction_a, nano::account const & account_a) override; store::iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override; diff --git a/nano/store/pending.hpp b/nano/store/pending.hpp index 1531c7f7cc..49f2b8a31c 100644 --- a/nano/store/pending.hpp +++ b/nano/store/pending.hpp @@ -5,6 +5,7 @@ #include #include +#include namespace nano { @@ -22,7 +23,7 @@ class pending public: virtual void put (store::write_transaction const &, nano::pending_key const &, nano::pending_info const &) = 0; virtual void del (store::write_transaction const &, nano::pending_key const &) = 0; - virtual bool get (store::transaction const &, nano::pending_key const &, nano::pending_info &) = 0; + virtual std::optional get (store::transaction const &, nano::pending_key const &) = 0; virtual bool exists (store::transaction const &, nano::pending_key const &) = 0; virtual bool any (store::transaction const &, nano::account const &) = 0; virtual store::iterator begin (store::transaction const &, nano::pending_key const &) const = 0; diff --git a/nano/store/rocksdb/pending.cpp b/nano/store/rocksdb/pending.cpp index f7e843f184..27efe5e637 100644 --- a/nano/store/rocksdb/pending.cpp +++ b/nano/store/rocksdb/pending.cpp @@ -17,16 +17,18 @@ void nano::store::rocksdb::pending::del (store::write_transaction const & transa store.release_assert_success (status); } -bool nano::store::rocksdb::pending::get (store::transaction const & transaction, nano::pending_key const & key, nano::pending_info & pending) +std::optional nano::store::rocksdb::pending::get (store::transaction const & transaction, nano::pending_key const & key) { nano::store::rocksdb::db_val value; auto status1 = store.get (transaction, tables::pending, key, value); release_assert (store.success (status1) || store.not_found (status1)); - bool result (true); + std::optional result; if (store.success (status1)) { nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = pending.deserialize (stream); + result = nano::pending_info{}; + auto error = result.value ().deserialize (stream); + release_assert (!error); } return result; } diff --git a/nano/store/rocksdb/pending.hpp b/nano/store/rocksdb/pending.hpp index 76a5f67d6d..0ee4ced54a 100644 --- a/nano/store/rocksdb/pending.hpp +++ b/nano/store/rocksdb/pending.hpp @@ -13,7 +13,7 @@ class pending : public nano::store::pending explicit pending (nano::store::rocksdb::component & store_a); void put (store::write_transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info const & pending_info_a) override; void del (store::write_transaction const & transaction_a, nano::pending_key const & key_a) override; - bool get (store::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info & pending_a) override; + std::optional get (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool any (store::transaction const & transaction_a, nano::account const & account_a) override; store::iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override; From da4e9eb66a0fd723c06d1690e17aba2601755988 Mon Sep 17 00:00:00 2001 From: RickiNano <81099017+RickiNano@users.noreply.github.com> Date: Tue, 12 Mar 2024 12:50:33 +0100 Subject: [PATCH 187/190] Changed description of request_aggregator_threads (#4477) * Changed description of request_aggregator_threads to something more user friendly * Improved description --- nano/node/nodeconfig.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index e5b2cad9fb..16f3c897b8 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -130,7 +130,7 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const toml.put ("max_work_generate_multiplier", max_work_generate_multiplier, "Maximum allowed difficulty multiplier for work generation.\ntype:double,[1..]"); toml.put ("frontiers_confirmation", serialize_frontiers_confirmation (frontiers_confirmation), "Mode controlling frontier confirmation rate.\ntype:string,{auto,always,disabled}"); toml.put ("max_queued_requests", max_queued_requests, "Limit for number of queued confirmation requests for one channel, after which new requests are dropped until the queue drops below this value.\ntype:uint32"); - toml.put ("request_aggregator_threads", request_aggregator_threads, "Number of threads to dedicate to request aggregator. The default value is the minimum of 4 or the number returned by nano::hardware_concurency(), which is the number of hardware threads or the value of the environment variable NANO_HARDWARE_CONCURRENCY."); + toml.put ("request_aggregator_threads", request_aggregator_threads, "Number of threads to dedicate to request aggregator. Defaults to using all cpu threads, up to a maximum of 4"); toml.put ("max_unchecked_blocks", max_unchecked_blocks, "Maximum number of unchecked blocks to store in memory. Defaults to 65536. \ntype:uint64,[0..]"); toml.put ("rep_crawler_weight_minimum", rep_crawler_weight_minimum.to_string_dec (), "Rep crawler minimum weight, if this is less than minimum principal weight then this is taken as the minimum weight a rep must have to be tracked. If you want to track all reps set this to 0. If you do not want this to influence anything then set it to max value. This is only useful for debugging or for people who really know what they are doing.\ntype:string,amount,raw"); toml.put ("backlog_scan_batch_size", backlog_scan_batch_size, "Number of accounts per second to process when doing backlog population scan. Increasing this value will help unconfirmed frontiers get into election prioritization queue faster, however it will also increase resource usage. \ntype:uint"); From 97cc02ce29325790f3ed4a7465744c5620fefff2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Wed, 13 Mar 2024 09:56:35 +0100 Subject: [PATCH 188/190] Allow easy printing ranges of objects (#4488) --- nano/core_test/object_stream.cpp | 34 +++++++++++++++++++- nano/lib/object_stream.hpp | 3 +- nano/lib/object_stream_adapters.hpp | 49 +++++++++++++++++++++-------- 3 files changed, 70 insertions(+), 16 deletions(-) diff --git a/nano/core_test/object_stream.cpp b/nano/core_test/object_stream.cpp index ead8bad719..11f14922ff 100644 --- a/nano/core_test/object_stream.cpp +++ b/nano/core_test/object_stream.cpp @@ -556,4 +556,36 @@ TEST (object_stream, to_json) )"); ASSERT_EQ (str, expected); -} \ No newline at end of file +} + +TEST (object_stream, print_range) +{ + std::deque objects; + objects.push_back ({ 1 }); + objects.push_back ({ 2 }); + objects.push_back ({ 3 }); + + std::stringstream ss1, ss2; + ss1 << nano::streamed_range (objects); + ss2 << fmt::format ("{}", nano::streamed_range (objects)); + + auto expected = trim (R"( +[ + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000001", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000002", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + uint256_union_field: "0000000000000000000000000000000000000000000000000000000000000003", + block_hash: "0000000000000000000000000000000000000000000000000000000000000000" + } +] +)"); + + ASSERT_EQ (ss1.str (), expected); + ASSERT_EQ (ss2.str (), expected); +} diff --git a/nano/lib/object_stream.hpp b/nano/lib/object_stream.hpp index 40c638df91..f51e6feb06 100644 --- a/nano/lib/object_stream.hpp +++ b/nano/lib/object_stream.hpp @@ -281,7 +281,7 @@ class array_stream : private object_stream_base array_stream (array_stream const &) = delete; // Disallow copying -private: +public: template void write_single (Value const & value) { @@ -290,7 +290,6 @@ class array_stream : private object_stream_base ctx.end_array_element (); } -public: // Handle `.write (container)` template void write (Container const & container) diff --git a/nano/lib/object_stream_adapters.hpp b/nano/lib/object_stream_adapters.hpp index 8be5b445f4..29e372c86d 100644 --- a/nano/lib/object_stream_adapters.hpp +++ b/nano/lib/object_stream_adapters.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -9,42 +10,64 @@ namespace nano { -template +template struct object_stream_formatter { nano::object_stream_config const & config; Streamable const & value; + Writer writer; - explicit object_stream_formatter (Streamable const & value, nano::object_stream_config const & config) : + explicit object_stream_formatter (Streamable const & value, Writer writer, nano::object_stream_config const & config) : config{ config }, - value{ value } + value{ value }, + writer{ writer } { } - friend std::ostream & operator<< (std::ostream & os, object_stream_formatter const & self) + friend std::ostream & operator<< (std::ostream & os, object_stream_formatter const & self) { nano::root_object_stream obs{ os, self.config }; - obs.write (self.value); + self.writer (self.value, obs); return os; } // Needed for fmt formatting, uses the ostream operator under the hood - friend auto format_as (object_stream_formatter const & val) + friend auto format_as (object_stream_formatter const & self) { - return fmt::streamed (val); + return fmt::streamed (self); } }; -template -auto streamed (Streamable const & value) +enum class streamed_format +{ + basic, + json +}; + +inline nano::object_stream_config const & to_object_stream_config (streamed_format format) { - return object_stream_formatter{ value, nano::object_stream_config::default_config () }; + switch (format) + { + case streamed_format::basic: + return nano::object_stream_config::default_config (); + case streamed_format::json: + return nano::object_stream_config::json_config (); + default: + debug_assert (false); + return nano::object_stream_config::default_config (); + } } template -auto streamed_as_json (Streamable const & value) +auto streamed (Streamable const & value, streamed_format format = streamed_format::basic) +{ + return object_stream_formatter{ value, [] (auto const & value, nano::root_object_stream & obs) { obs.write (value); }, to_object_stream_config (format) }; +} + +template +auto streamed_range (StreamableRange const & value, streamed_format format = streamed_format::basic) { - return object_stream_formatter{ value, nano::object_stream_config::json_config () }; + return object_stream_formatter{ value, [] (auto const & value, nano::root_object_stream & obs) { obs.write_range (value); }, to_object_stream_config (format) }; } /** @@ -109,7 +132,7 @@ template std::string to_json (Value const & value) { std::stringstream ss; - ss << nano::streamed_as_json (value); + ss << nano::streamed (value, nano::streamed_format::json); return ss.str (); } } From 7dbf64f11c2b7d7c193a27d6cbfee6c474a11d9e Mon Sep 17 00:00:00 2001 From: Gustav Schauwecker Date: Wed, 13 Mar 2024 10:20:16 +0100 Subject: [PATCH 189/190] Fix build error with new optional pending_info (#4487) --- nano/secure/ledger.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index e317652891..8e69bde8ef 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -593,7 +593,7 @@ void ledger_processor::receive_block (nano::receive_block & block_a) #ifdef NDEBUG if (ledger.store.block.exists (transaction, block_a.hashables.source)) { - auto info = ledger.account_info (transaction, pending.source); + auto info = ledger.account_info (transaction, pending.value ().source); debug_assert (info); } #endif @@ -659,7 +659,7 @@ void ledger_processor::open_block (nano::open_block & block_a) if (ledger.store.block.exists (transaction, block_a.hashables.source)) { nano::account_info source_info; - [[maybe_unused]] auto error (ledger.store.account.get (transaction, pending.source, source_info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, pending.value ().source, source_info)); debug_assert (!error); } #endif From 752317263499aca6ec54119c308267df33173f73 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 14 Mar 2024 15:00:18 +0000 Subject: [PATCH 190/190] Add functions to allow pending_key objects to be in containers. (#4489) --- nano/core_test/utility.cpp | 14 ++++++++++++++ nano/secure/pending_info.cpp | 5 +++++ nano/secure/pending_info.hpp | 13 +++++++++++++ 3 files changed, 32 insertions(+) diff --git a/nano/core_test/utility.cpp b/nano/core_test/utility.cpp index 1bd6a50c2b..730714dc83 100644 --- a/nano/core_test/utility.cpp +++ b/nano/core_test/utility.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -346,3 +347,16 @@ TEST (relaxed_atomic_integral, many_threads) // Check values ASSERT_EQ (0, atomic); } + +TEST (pending_key, sorting) +{ + nano::pending_key one{ 1, 2 }; + nano::pending_key two{ 1, 3 }; + nano::pending_key three{ 2, 1 }; + ASSERT_LT (one, two); + ASSERT_LT (one, three); + ASSERT_LT (two, three); + nano::pending_key one_same{ 1, 2 }; + ASSERT_EQ (std::hash{}(one), std::hash{}(one_same)); + ASSERT_NE (std::hash{}(one), std::hash{}(two)); +} diff --git a/nano/secure/pending_info.cpp b/nano/secure/pending_info.cpp index 24aa14b3ad..637f4adf74 100644 --- a/nano/secure/pending_info.cpp +++ b/nano/secure/pending_info.cpp @@ -65,3 +65,8 @@ nano::account const & nano::pending_key::key () const { return account; } + +bool nano::pending_key::operator< (nano::pending_key const & other_a) const +{ + return account == other_a.account ? hash < other_a.hash : account < other_a.account; +} diff --git a/nano/secure/pending_info.hpp b/nano/secure/pending_info.hpp index 4e69460399..584337e95e 100644 --- a/nano/secure/pending_info.hpp +++ b/nano/secure/pending_info.hpp @@ -28,8 +28,21 @@ class pending_key final pending_key (nano::account const &, nano::block_hash const &); bool deserialize (nano::stream &); bool operator== (nano::pending_key const &) const; + bool operator< (nano::pending_key const &) const; nano::account const & key () const; nano::account account{}; nano::block_hash hash{ 0 }; }; } // namespace nano + +namespace std +{ +template <> +struct hash<::nano::pending_key> +{ + size_t operator() (::nano::pending_key const & data_a) const + { + return hash<::nano::uint512_union>{}({ ::nano::uint256_union{ data_a.account.number () }, data_a.hash }); + } +}; +}