From ccd3c46917ec8b69585c782bbe4231ac13ea8fee Mon Sep 17 00:00:00 2001 From: Airtune Date: Fri, 26 Nov 2021 15:37:35 +0100 Subject: [PATCH 1/2] Add nano::message_header::to_string () --- nano/core_test/message.cpp | 20 +++++++++++++ nano/node/common.cpp | 58 ++++++++++++++++++++++++++++++++++++++ nano/node/common.hpp | 3 ++ nano/node/network.cpp | 20 +++++++++++++ nano/node/network.hpp | 1 + 5 files changed, 102 insertions(+) diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 13c71fd374..ce468db5eb 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -4,6 +4,7 @@ #include +#include #include TEST (message, keepalive_serialization) @@ -201,3 +202,22 @@ TEST (message, confirm_req_hash_batch_serialization) ASSERT_EQ (header.block_type (), nano::block_type::not_a_block); ASSERT_EQ (header.count_get (), req.roots_hashes.size ()); } + +TEST (message, keepalive_to_string) +{ + // header identical to keepalive_serialization at the top of this file + nano::keepalive request1{ nano::dev::network_params.network }; + std::vector bytes; + { + nano::vectorstream stream (bytes); + request1.serialize (stream); + } + auto error (false); + nano::bufferstream stream (bytes.data (), bytes.size ()); + nano::message_header header (error, stream); + + std::string header_string = header.to_string (); + + ASSERT_TRUE (boost::algorithm::contains (header_string, "MsgType: 2(keepalive)")); + ASSERT_FALSE (boost::algorithm::contains (header_string, ": ,")); +} diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 77c0ea3c3f..d52a70a62e 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -4,14 +4,17 @@ #include #include #include +#include #include #include #include +#include #include #include #include +#include std::bitset<16> constexpr nano::message_header::block_type_mask; std::bitset<16> constexpr nano::message_header::count_mask; @@ -90,6 +93,61 @@ bool nano::message_header::deserialize (nano::stream & stream_a) return error; } +std::string nano::message_type_to_string (nano::message_type message_type_l) +{ + switch (message_type_l) + { + 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"; + // default case intentionally omitted to cause warnings for unhandled enums + } + + return "n/a"; +} + +std::string nano::message_header::to_string () +{ + // 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); + std::string type_text = nano::message_type_to_string (type); + + std::stringstream stream; + + stream << boost::format ("NetID: %1%, ") % nano::network::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%") % extensions.to_ulong (); + + return stream.str (); +} + nano::message::message (nano::network_constants const & constants, nano::message_type type_a) : header (constants, type_a) { diff --git a/nano/node/common.hpp b/nano/node/common.hpp index 67a299a7ed..6f7b86d322 100644 --- a/nano/node/common.hpp +++ b/nano/node/common.hpp @@ -189,6 +189,8 @@ enum class message_type : uint8_t telemetry_ack = 0x0d }; +std::string message_type_to_string (message_type); + enum class bulk_pull_account_flags : uint8_t { pending_hash_and_amount = 0x0, @@ -212,6 +214,7 @@ class message_header final uint8_t version_max; uint8_t version_using; uint8_t version_min; + std::string to_string (); public: nano::message_type type; diff --git a/nano/node/network.cpp b/nano/node/network.cpp index d47f1f4096..c3471f2941 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -1079,3 +1079,23 @@ 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 "B(beta_network)"; + case nano::networks::nano_dev_network: + return "dev_network"; + case nano::networks::nano_live_network: + return "C(live_network)"; + case nano::networks::nano_test_network: + return "A(test_network)"; + // 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 43f510ad06..c87c0e1505 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -170,6 +170,7 @@ class network final bool empty () const; void erase (nano::transport::channel const &); void set_bandwidth_params (double, std::size_t); + static std::string to_string (nano::networks); private: void process_message (nano::message const &, std::shared_ptr const &); From 70a19cd5bf153a396426b92fb69105addf23834f Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Sun, 5 Dec 2021 14:10:29 +0200 Subject: [PATCH 2/2] Improve message_header to string output and add unit test Printing out raw network ID as a number not just text and printing out extensions as a bitfield. --- nano/core_test/message.cpp | 27 ++++++++++++--------------- nano/lib/numbers.cpp | 8 ++++++++ nano/lib/numbers.hpp | 1 + nano/node/common.cpp | 4 ++-- nano/node/network.cpp | 8 ++++---- 5 files changed, 27 insertions(+), 21 deletions(-) diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index ce468db5eb..515d451b9c 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -203,21 +203,18 @@ TEST (message, confirm_req_hash_batch_serialization) ASSERT_EQ (header.count_get (), req.roots_hashes.size ()); } -TEST (message, keepalive_to_string) +// this unit test checks that conversion of message_header to string works as expected +TEST (message, message_header_to_string) { - // header identical to keepalive_serialization at the top of this file - nano::keepalive request1{ nano::dev::network_params.network }; - std::vector bytes; - { - nano::vectorstream stream (bytes); - request1.serialize (stream); - } - auto error (false); - nano::bufferstream stream (bytes.data (), bytes.size ()); - nano::message_header header (error, stream); - - std::string header_string = 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 (); - ASSERT_TRUE (boost::algorithm::contains (header_string, "MsgType: 2(keepalive)")); - ASSERT_FALSE (boost::algorithm::contains (header_string, ": ,")); + // 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); } diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp index 63cc96b199..aedd16a027 100644 --- a/nano/lib/numbers.cpp +++ b/nano/lib/numbers.cpp @@ -870,6 +870,14 @@ std::string nano::to_string_hex (uint64_t const value_a) return stream.str (); } +std::string nano::to_string_hex (uint16_t const value_a) +{ + std::stringstream stream; + stream << std::hex << std::noshowbase << std::setw (4) << std::setfill ('0'); + stream << value_a; + return stream.str (); +} + bool nano::from_string_hex (std::string const & value_a, uint64_t & target_a) { auto error (value_a.empty ()); diff --git a/nano/lib/numbers.hpp b/nano/lib/numbers.hpp index 77775d5998..dc3c2b1d2f 100644 --- a/nano/lib/numbers.hpp +++ b/nano/lib/numbers.hpp @@ -253,6 +253,7 @@ nano::public_key pub_key (nano::raw_key const &); /* Conversion methods */ 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 &); /** diff --git a/nano/node/common.cpp b/nano/node/common.cpp index d52a70a62e..b709738a50 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -140,10 +140,10 @@ std::string nano::message_header::to_string () std::stringstream stream; - stream << boost::format ("NetID: %1%, ") % nano::network::to_string (network); + stream << boost::format ("NetID: %1%(%2%), ") % nano::to_string_hex (static_cast (network)) % nano::network::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%") % extensions.to_ulong (); + stream << boost::format ("Extensions: %1%") % nano::to_string_hex (static_cast (extensions.to_ulong ())); return stream.str (); } diff --git a/nano/node/network.cpp b/nano/node/network.cpp index c3471f2941..99aa8626b6 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -1087,13 +1087,13 @@ std::string nano::network::to_string (nano::networks network) case nano::networks::invalid: return "invalid"; case nano::networks::nano_beta_network: - return "B(beta_network)"; + return "beta"; case nano::networks::nano_dev_network: - return "dev_network"; + return "dev"; case nano::networks::nano_live_network: - return "C(live_network)"; + return "live"; case nano::networks::nano_test_network: - return "A(test_network)"; + return "test"; // default case intentionally omitted to cause warnings for unhandled enums }