From 033d8b50439a408538fd099e6eaadeebcd7380ca Mon Sep 17 00:00:00 2001 From: Wesley Shillingford Date: Fri, 31 Jan 2020 15:08:44 +0000 Subject: [PATCH] Extend telemetry data with more node versioning details (#2524) * Extend telemetry data with more node versioning details * Merge with develop * Add pre_release version for DBs and RCs * Forget to add CMakeLists.txt file * Formatting --- CMakeLists.txt | 1 + nano/core_test/node_telemetry.cpp | 131 ++++++++++++++++++++++++++---- nano/lib/CMakeLists.txt | 3 + nano/lib/config.cpp | 12 +++ nano/lib/config.hpp | 6 ++ nano/node/common.cpp | 102 +++++++++++++++++++---- nano/node/common.hpp | 11 ++- nano/node/network.cpp | 8 +- nano/rpc_test/rpc.cpp | 30 +++++-- 9 files changed, 260 insertions(+), 44 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9507694c..32ee415c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,7 @@ set (CI_TEST 0 CACHE STRING "") set (CPACK_PACKAGE_VERSION_MAJOR "21") set (CPACK_PACKAGE_VERSION_MINOR "0") set (CPACK_PACKAGE_VERSION_PATCH "0") +set (CPACK_PACKAGE_VERSION_PRE_RELEASE "0") set (CPACK_PACKAGE_VENDOR "Nano Currency") if (CI_BUILD) diff --git a/nano/core_test/node_telemetry.cpp b/nano/core_test/node_telemetry.cpp index 7ead20ae..7bd76d41 100644 --- a/nano/core_test/node_telemetry.cpp +++ b/nano/core_test/node_telemetry.cpp @@ -16,41 +16,52 @@ void compare_default_test_result_data (nano::telemetry_data const & telemetry_da TEST (node_telemetry, consolidate_data) { + // Pick specific values so that we can check both mode and average are working correctly nano::telemetry_data data; data.account_count = 2; data.block_count = 1; data.cemented_count = 1; - data.vendor_version = 20; - data.protocol_version_number = 12; + data.protocol_version = 12; data.peer_count = 2; data.bandwidth_cap = 100; data.unchecked_count = 3; data.uptime = 6; data.genesis_block = nano::block_hash (3); + data.major_version = 20; + data.minor_version = 1; + data.patch_version = 4; + data.pre_release_version = 6; nano::telemetry_data data1; data1.account_count = 5; data1.block_count = 7; data1.cemented_count = 4; - data1.vendor_version = 10; - data1.protocol_version_number = 11; + data1.protocol_version = 11; data1.peer_count = 5; data1.bandwidth_cap = 0; data1.unchecked_count = 1; data1.uptime = 10; data1.genesis_block = nano::block_hash (4); + data1.major_version = 10; + data1.minor_version = 2; + data1.patch_version = 3; + data1.pre_release_version = 6; + data1.maker = 2; nano::telemetry_data data2; data2.account_count = 3; data2.block_count = 3; data2.cemented_count = 2; - data2.vendor_version = 20; - data2.protocol_version_number = 11; + data2.protocol_version = 11; data2.peer_count = 4; data2.bandwidth_cap = 0; data2.unchecked_count = 2; data2.uptime = 3; data2.genesis_block = nano::block_hash (4); + data2.major_version = 20; + data2.minor_version = 1; + data2.patch_version = 4; + data2.pre_release_version = 6; std::vector all_data{ data, data1, data2 }; @@ -58,23 +69,35 @@ TEST (node_telemetry, consolidate_data) ASSERT_EQ (consolidated_telemetry_data.account_count, 3); ASSERT_EQ (consolidated_telemetry_data.block_count, 3); ASSERT_EQ (consolidated_telemetry_data.cemented_count, 2); - ASSERT_EQ (consolidated_telemetry_data.vendor_version, 20); - ASSERT_EQ (consolidated_telemetry_data.protocol_version_number, 11); + ASSERT_EQ (consolidated_telemetry_data.protocol_version, 11); ASSERT_EQ (consolidated_telemetry_data.peer_count, 3); ASSERT_EQ (consolidated_telemetry_data.bandwidth_cap, 0); ASSERT_EQ (consolidated_telemetry_data.unchecked_count, 2); ASSERT_EQ (consolidated_telemetry_data.uptime, 6); ASSERT_EQ (consolidated_telemetry_data.genesis_block, nano::block_hash (4)); + ASSERT_EQ (consolidated_telemetry_data.major_version, 20); + ASSERT_FALSE (consolidated_telemetry_data.minor_version.is_initialized ()); + ASSERT_FALSE (consolidated_telemetry_data.patch_version.is_initialized ()); + ASSERT_FALSE (consolidated_telemetry_data.pre_release_version.is_initialized ()); + ASSERT_FALSE (consolidated_telemetry_data.maker.is_initialized ()); // Modify the metrics which may be either the mode or averages to ensure all are tested. all_data[2].bandwidth_cap = 53; - all_data[2].protocol_version_number = 13; - all_data[2].vendor_version = 13; + all_data[2].protocol_version = 13; all_data[2].genesis_block = nano::block_hash (3); + all_data[2].major_version = 10; + all_data[2].minor_version = 2; + all_data[2].patch_version = 3; + all_data[2].pre_release_version = 6; + all_data[2].maker = 2; auto consolidated_telemetry_data1 = nano::telemetry_data::consolidate (all_data); - ASSERT_TRUE (consolidated_telemetry_data1.vendor_version == 10 || consolidated_telemetry_data1.vendor_version == 13 || consolidated_telemetry_data1.vendor_version == 20); - ASSERT_TRUE (consolidated_telemetry_data1.protocol_version_number == 11 || consolidated_telemetry_data1.protocol_version_number == 12 || consolidated_telemetry_data1.protocol_version_number == 13); + ASSERT_EQ (consolidated_telemetry_data1.major_version, 10); + ASSERT_EQ (*consolidated_telemetry_data1.minor_version, 2); + ASSERT_EQ (*consolidated_telemetry_data1.patch_version, 3); + ASSERT_EQ (*consolidated_telemetry_data1.pre_release_version, 6); + ASSERT_EQ (*consolidated_telemetry_data1.maker, 2); + ASSERT_TRUE (consolidated_telemetry_data1.protocol_version == 11 || consolidated_telemetry_data1.protocol_version == 12 || consolidated_telemetry_data1.protocol_version == 13); ASSERT_EQ (consolidated_telemetry_data1.bandwidth_cap, 51); ASSERT_EQ (consolidated_telemetry_data1.genesis_block, nano::block_hash (3)); @@ -83,6 +106,74 @@ TEST (node_telemetry, consolidate_data) ASSERT_EQ (consolidated_telemetry_data, consolidated_telemetry_data); } +TEST (node_telemetry, consolidate_data_optional_data) +{ + nano::telemetry_data data; + data.major_version = 20; + data.minor_version = 1; + data.patch_version = 4; + data.pre_release_version = 6; + data.maker = 2; + + nano::telemetry_data missing_minor; + missing_minor.major_version = 20; + missing_minor.patch_version = 4; + + nano::telemetry_data missing_all_optional; + + std::vector all_data{ data, data, missing_minor, missing_all_optional }; + auto consolidated_telemetry_data = nano::telemetry_data::consolidate (all_data); + ASSERT_EQ (consolidated_telemetry_data.major_version, 20); + ASSERT_EQ (*consolidated_telemetry_data.minor_version, 1); + ASSERT_EQ (*consolidated_telemetry_data.patch_version, 4); + ASSERT_EQ (*consolidated_telemetry_data.pre_release_version, 6); + ASSERT_EQ (*consolidated_telemetry_data.maker, 2); +} + +TEST (node_telemetry, serialize_deserialize_json_optional) +{ + nano::telemetry_data data; + data.minor_version = 1; + data.patch_version = 4; + data.pre_release_version = 6; + data.maker = 2; + + nano::jsonconfig config; + data.serialize_json (config); + + uint8_t val; + ASSERT_FALSE (config.get ("minor_version", val).get_error ()); + ASSERT_EQ (val, 1); + ASSERT_FALSE (config.get ("patch_version", val).get_error ()); + ASSERT_EQ (val, 4); + ASSERT_FALSE (config.get ("pre_release_version", val).get_error ()); + ASSERT_EQ (val, 6); + ASSERT_FALSE (config.get ("maker", val).get_error ()); + ASSERT_EQ (val, 2); + + nano::telemetry_data data1; + data1.deserialize_json (config); + ASSERT_EQ (*data1.minor_version, 1); + ASSERT_EQ (*data1.patch_version, 4); + ASSERT_EQ (*data1.pre_release_version, 6); + ASSERT_EQ (*data1.maker, 2); + + nano::telemetry_data no_optional_data; + nano::jsonconfig config1; + no_optional_data.serialize_json (config1); + ASSERT_FALSE (config1.get_optional ("minor_version").is_initialized ()); + ASSERT_FALSE (config1.get_optional ("patch_version").is_initialized ()); + ASSERT_FALSE (config1.get_optional ("pre_release_version").is_initialized ()); + ASSERT_FALSE (config1.get_optional ("maker").is_initialized ()); + + nano::telemetry_data no_optional_data1; + no_optional_data1.deserialize_json (config1); + ASSERT_FALSE (no_optional_data1.minor_version.is_initialized ()); + ASSERT_FALSE (no_optional_data1.patch_version.is_initialized ()); + ASSERT_FALSE (no_optional_data1.pre_release_version.is_initialized ()); + ASSERT_FALSE (no_optional_data1.maker.is_initialized ()); +} + TEST (node_telemetry, no_peers) { nano::system system (1); @@ -223,10 +314,14 @@ TEST (node_telemetry, many_nodes) ASSERT_LE (data.peer_count, 9); ASSERT_EQ (data.account_count, 1); ASSERT_TRUE (data.block_count == 2); - ASSERT_EQ (data.protocol_version_number, params.protocol.telemetry_protocol_version_min); + ASSERT_EQ (data.protocol_version, params.protocol.telemetry_protocol_version_min); ASSERT_GE (data.bandwidth_cap, 100000); ASSERT_LT (data.bandwidth_cap, 100000 + system.nodes.size ()); - ASSERT_EQ (data.vendor_version, nano::get_major_node_version ()); + ASSERT_EQ (data.major_version, nano::get_major_node_version ()); + ASSERT_EQ (*data.minor_version, nano::get_minor_node_version ()); + ASSERT_EQ (*data.patch_version, nano::get_patch_node_version ()); + ASSERT_EQ (*data.pre_release_version, nano::get_pre_release_node_version ()); + ASSERT_EQ (*data.maker, 0); ASSERT_LT (data.uptime, 100); ASSERT_EQ (data.genesis_block, genesis.hash ()); } @@ -826,10 +921,14 @@ void compare_default_test_result_data (nano::telemetry_data const & telemetry_da ASSERT_EQ (telemetry_data_a.cemented_count, 1); ASSERT_EQ (telemetry_data_a.bandwidth_cap, node_server_a.config.bandwidth_limit); ASSERT_EQ (telemetry_data_a.peer_count, 1); - ASSERT_EQ (telemetry_data_a.protocol_version_number, node_server_a.network_params.protocol.telemetry_protocol_version_min); + ASSERT_EQ (telemetry_data_a.protocol_version, node_server_a.network_params.protocol.telemetry_protocol_version_min); ASSERT_EQ (telemetry_data_a.unchecked_count, 0); ASSERT_EQ (telemetry_data_a.account_count, 1); - ASSERT_EQ (telemetry_data_a.vendor_version, nano::get_major_node_version ()); + ASSERT_EQ (telemetry_data_a.major_version, nano::get_major_node_version ()); + ASSERT_EQ (*telemetry_data_a.minor_version, nano::get_minor_node_version ()); + ASSERT_EQ (*telemetry_data_a.patch_version, nano::get_patch_node_version ()); + ASSERT_EQ (*telemetry_data_a.pre_release_version, nano::get_pre_release_node_version ()); + ASSERT_EQ (*telemetry_data_a.maker, 0); ASSERT_LT (telemetry_data_a.uptime, 100); ASSERT_EQ (telemetry_data_a.genesis_block, nano::genesis ().hash ()); } diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 6d25e5fb..b8468a6b 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -80,6 +80,9 @@ endif () target_compile_definitions(nano_lib PRIVATE -DMAJOR_VERSION_STRING=${CPACK_PACKAGE_VERSION_MAJOR} + -DMINOR_VERSION_STRING=${CPACK_PACKAGE_VERSION_MINOR} + -DPATCH_VERSION_STRING=${CPACK_PACKAGE_VERSION_PATCH} + -DPRE_RELEASE_VERSION_STRING=${CPACK_PACKAGE_VERSION_PRE_RELEASE} PUBLIC -DACTIVE_NETWORK=${ACTIVE_NETWORK} ) diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index 7fcc7c44..65b9f977 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -13,6 +13,18 @@ uint8_t get_major_node_version () { return boost::numeric_cast (boost::lexical_cast (NANO_MAJOR_VERSION_STRING)); } +uint8_t get_minor_node_version () +{ + return boost::numeric_cast (boost::lexical_cast (NANO_MINOR_VERSION_STRING)); +} +uint8_t get_patch_node_version () +{ + return boost::numeric_cast (boost::lexical_cast (NANO_PATCH_VERSION_STRING)); +} +uint8_t get_pre_release_node_version () +{ + return boost::numeric_cast (boost::lexical_cast (NANO_PRE_RELEASE_VERSION_STRING)); +} void force_nano_test_network () { diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index 1790f316..469fc261 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -21,6 +21,9 @@ namespace filesystem */ const char * const NANO_VERSION_STRING = xstr (TAG_VERSION_STRING); const char * const NANO_MAJOR_VERSION_STRING = xstr (MAJOR_VERSION_STRING); +const char * const NANO_MINOR_VERSION_STRING = xstr (MINOR_VERSION_STRING); +const char * const NANO_PATCH_VERSION_STRING = xstr (PATCH_VERSION_STRING); +const char * const NANO_PRE_RELEASE_VERSION_STRING = xstr (PRE_RELEASE_VERSION_STRING); const char * const BUILD_INFO = xstr (GIT_COMMIT_HASH BOOST_COMPILER) " \"BOOST " xstr (BOOST_VERSION) "\" BUILT " xstr (__DATE__); @@ -41,6 +44,9 @@ const bool is_sanitizer_build = false; namespace nano { uint8_t get_major_node_version (); +uint8_t get_minor_node_version (); +uint8_t get_patch_node_version (); +uint8_t get_pre_release_node_version (); /** * Network variants with different genesis blocks and network parameters diff --git a/nano/node/common.cpp b/nano/node/common.cpp index b63b1e58..df03cb55 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include @@ -1103,10 +1104,14 @@ void nano::telemetry_ack::serialize (nano::stream & stream_a) const write (stream_a, data.account_count); write (stream_a, data.bandwidth_cap); write (stream_a, data.peer_count); - write (stream_a, data.protocol_version_number); - write (stream_a, data.vendor_version); + write (stream_a, data.protocol_version); + write (stream_a, data.major_version); write (stream_a, data.uptime); write (stream_a, data.genesis_block.bytes); + write (stream_a, *data.minor_version); + write (stream_a, *data.patch_version); + write (stream_a, *data.pre_release_version); + write (stream_a, *data.maker); } } @@ -1124,10 +1129,23 @@ bool nano::telemetry_ack::deserialize (nano::stream & stream_a) read (stream_a, data.account_count); read (stream_a, data.bandwidth_cap); read (stream_a, data.peer_count); - read (stream_a, data.protocol_version_number); - read (stream_a, data.vendor_version); + read (stream_a, data.protocol_version); + read (stream_a, data.major_version); read (stream_a, data.uptime); read (stream_a, data.genesis_block.bytes); + + if (header.extensions.to_ulong () > telemetry_data::size_v0) + { + uint8_t out; + read (stream_a, out); + data.minor_version = out; + read (stream_a, out); + data.patch_version = out; + read (stream_a, out); + data.pre_release_version = out; + read (stream_a, out); + data.maker = out; + } } } catch (std::runtime_error const &) @@ -1179,7 +1197,7 @@ nano::telemetry_data nano::telemetry_data::consolidate (std::vector protocol_versions; - std::unordered_map vendor_versions; + std::unordered_map vendor_versions; std::unordered_map bandwidth_caps; std::unordered_map genesis_blocks; @@ -1190,8 +1208,28 @@ nano::telemetry_data nano::telemetry_data::consolidate (std::vector version_fragments; + boost::split (version_fragments, version, boost::is_any_of (".")); + assert (!version_fragments.empty () && version_fragments.size () <= 5); + consolidated_data.major_version = boost::lexical_cast (version_fragments.front ()); + if (version_fragments.size () == 5) + { + consolidated_data.minor_version = boost::lexical_cast (version_fragments[1]); + consolidated_data.patch_version = boost::lexical_cast (version_fragments[2]); + consolidated_data.pre_release_version = boost::lexical_cast (version_fragments[3]); + consolidated_data.maker = boost::lexical_cast (version_fragments[4]); + } return consolidated_data; } @@ -1260,10 +1313,26 @@ nano::error nano::telemetry_data::serialize_json (nano::jsonconfig & json) const json.put ("account_count", account_count); json.put ("bandwidth_cap", bandwidth_cap); json.put ("peer_count", peer_count); - json.put ("protocol_version_number", protocol_version_number); - json.put ("vendor_version", vendor_version); + json.put ("protocol_version", protocol_version); json.put ("uptime", uptime); json.put ("genesis_block", genesis_block.to_string ()); + json.put ("major_version", major_version); + if (minor_version.is_initialized ()) + { + json.put ("minor_version", *minor_version); + } + if (patch_version.is_initialized ()) + { + json.put ("patch_version", *patch_version); + } + if (pre_release_version.is_initialized ()) + { + json.put ("pre_release_version", *pre_release_version); + } + if (maker.is_initialized ()) + { + json.put ("maker", *maker); + } return json.get_error (); } @@ -1275,8 +1344,7 @@ nano::error nano::telemetry_data::deserialize_json (nano::jsonconfig & json) json.get ("account_count", account_count); json.get ("bandwidth_cap", bandwidth_cap); json.get ("peer_count", peer_count); - json.get ("protocol_version_number", protocol_version_number); - json.get ("vendor_version", vendor_version); + json.get ("protocol_version", protocol_version); json.get ("uptime", uptime); std::string genesis_block_l; json.get ("genesis_block", genesis_block_l); @@ -1287,12 +1355,18 @@ nano::error nano::telemetry_data::deserialize_json (nano::jsonconfig & json) json.get_error ().set ("Could not deserialize genesis block"); } } + json.get ("major_version", major_version); + minor_version = json.get_optional ("minor_version"); + patch_version = json.get_optional ("patch_version"); + pre_release_version = json.get_optional ("pre_release_version"); + maker = json.get_optional ("maker"); + return json.get_error (); } bool nano::telemetry_data::operator== (nano::telemetry_data const & data_a) const { - return (block_count == data_a.block_count && cemented_count == data_a.cemented_count && unchecked_count == data_a.unchecked_count && account_count == data_a.account_count && bandwidth_cap == data_a.bandwidth_cap && uptime == data_a.uptime && peer_count == data_a.peer_count && protocol_version_number == data_a.protocol_version_number && vendor_version == data_a.vendor_version && genesis_block == data_a.genesis_block); + return (block_count == data_a.block_count && cemented_count == data_a.cemented_count && unchecked_count == data_a.unchecked_count && account_count == data_a.account_count && bandwidth_cap == data_a.bandwidth_cap && uptime == data_a.uptime && peer_count == data_a.peer_count && protocol_version == data_a.protocol_version && genesis_block == data_a.genesis_block && major_version == data_a.major_version && minor_version == data_a.minor_version && patch_version == data_a.patch_version && pre_release_version == data_a.pre_release_version && maker == data_a.maker); } nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : diff --git a/nano/node/common.hpp b/nano/node/common.hpp index d9c65616..1f4f4b4a 100644 --- a/nano/node/common.hpp +++ b/nano/node/common.hpp @@ -340,16 +340,21 @@ public: uint64_t bandwidth_cap{ 0 }; uint64_t uptime{ 0 }; uint32_t peer_count{ 0 }; - uint8_t protocol_version_number{ 0 }; - uint8_t vendor_version{ 0 }; + uint8_t protocol_version{ 0 }; + uint8_t major_version{ 0 }; nano::block_hash genesis_block{ 0 }; + boost::optional minor_version; + boost::optional patch_version; + boost::optional pre_release_version; + boost::optional maker; // 0 for NF node static nano::telemetry_data consolidate (std::vector const & telemetry_data_responses); nano::error serialize_json (nano::jsonconfig & json) const; nano::error deserialize_json (nano::jsonconfig & json); bool operator== (nano::telemetry_data const &) const; - static auto constexpr size = sizeof (block_count) + sizeof (cemented_count) + sizeof (unchecked_count) + sizeof (account_count) + sizeof (bandwidth_cap) + sizeof (peer_count) + sizeof (protocol_version_number) + sizeof (vendor_version) + sizeof (uptime) + sizeof (genesis_block); + static auto constexpr size_v0 = sizeof (block_count) + sizeof (cemented_count) + sizeof (unchecked_count) + sizeof (account_count) + sizeof (bandwidth_cap) + sizeof (peer_count) + sizeof (protocol_version) + sizeof (uptime) + sizeof (genesis_block) + sizeof (major_version); + static auto constexpr size = size_v0 + sizeof (decltype (minor_version)::value_type) + sizeof (decltype (patch_version)::value_type) + sizeof (decltype (pre_release_version)::value_type) + sizeof (decltype (maker)::value_type); }; class telemetry_req final : public message { diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 797d2df0..3341dcad 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -539,13 +539,17 @@ public: telemetry_data.block_count = node.ledger.cache.block_count; telemetry_data.cemented_count = node.ledger.cache.cemented_count; telemetry_data.bandwidth_cap = node.config.bandwidth_limit; - telemetry_data.protocol_version_number = node.network_params.protocol.protocol_version; - telemetry_data.vendor_version = nano::get_major_node_version (); + telemetry_data.protocol_version = node.network_params.protocol.protocol_version; telemetry_data.uptime = std::chrono::duration_cast (std::chrono::steady_clock::now () - node.startup_time).count (); telemetry_data.unchecked_count = node.ledger.cache.unchecked_count; telemetry_data.genesis_block = nano::genesis ().hash (); telemetry_data.peer_count = node.network.size (); telemetry_data.account_count = node.ledger.cache.account_count; + telemetry_data.major_version = nano::get_major_node_version (); + telemetry_data.minor_version = nano::get_minor_node_version (); + telemetry_data.patch_version = nano::get_patch_node_version (); + telemetry_data.pre_release_version = nano::get_pre_release_node_version (); + telemetry_data.maker = 0; // 0 Indicates it originated from the NF telemetry_ack = nano::telemetry_ack (telemetry_data); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index c5e2f336..bf60ca50 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -7844,10 +7844,14 @@ void compare_default_test_result_data (test_response & response, nano::node cons ASSERT_EQ (1, response.json.get ("account_count")); ASSERT_EQ (node_server_a.config.bandwidth_limit, response.json.get ("bandwidth_cap")); ASSERT_EQ (1, response.json.get ("peer_count")); - ASSERT_EQ (node_server_a.network_params.protocol.protocol_version, response.json.get ("protocol_version_number")); - ASSERT_EQ (nano::get_major_node_version (), response.json.get ("vendor_version")); + ASSERT_EQ (node_server_a.network_params.protocol.protocol_version, response.json.get ("protocol_version")); ASSERT_GE (100, response.json.get ("uptime")); ASSERT_EQ (nano::genesis ().hash ().to_string (), response.json.get ("genesis_block")); + ASSERT_EQ (nano::get_major_node_version (), response.json.get ("major_version")); + ASSERT_EQ (nano::get_minor_node_version (), response.json.get ("minor_version")); + ASSERT_EQ (nano::get_patch_node_version (), response.json.get ("patch_version")); + ASSERT_EQ (nano::get_pre_release_node_version (), response.json.get ("pre_release_version")); + ASSERT_EQ (0, response.json.get ("maker")); } } @@ -7990,10 +7994,14 @@ TEST (rpc, node_telemetry_random) ASSERT_EQ (1, response.json.get ("account_count")); ASSERT_EQ (node->config.bandwidth_limit, response.json.get ("bandwidth_cap")); ASSERT_EQ (1, response.json.get ("peer_count")); - ASSERT_EQ (node->network_params.protocol.protocol_version, response.json.get ("protocol_version_number")); - ASSERT_EQ (nano::get_major_node_version (), response.json.get ("vendor_version")); + ASSERT_EQ (node->network_params.protocol.protocol_version, response.json.get ("protocol_version")); ASSERT_GE (100, response.json.get ("uptime")); ASSERT_EQ (nano::genesis ().hash ().to_string (), response.json.get ("genesis_block")); + ASSERT_EQ (nano::get_major_node_version (), response.json.get ("major_version")); + ASSERT_EQ (nano::get_minor_node_version (), response.json.get ("minor_version")); + ASSERT_EQ (nano::get_patch_node_version (), response.json.get ("patch_version")); + ASSERT_EQ (nano::get_pre_release_node_version (), response.json.get ("pre_release_version")); + ASSERT_EQ (0, response.json.get ("maker")); } request.put ("raw", "true"); @@ -8009,11 +8017,11 @@ TEST (rpc, node_telemetry_random) ASSERT_TRUE (response.json.get ("cached")); auto & all_metrics = response.json.get_child ("metrics"); - std::vector> raw_metrics_json_l; + std::vector> raw_metrics_json_l; for (auto & metrics_pair : all_metrics) { auto & metrics = metrics_pair.second; - raw_metrics_json_l.emplace_back (metrics.get ("block_count"), metrics.get ("cemented_count"), metrics.get ("unchecked_count"), metrics.get ("account_count"), metrics.get ("bandwidth_cap"), metrics.get ("peer_count"), metrics.get ("protocol_version_number"), metrics.get ("vendor_version"), metrics.get ("uptime"), metrics.get ("genesis_block")); + raw_metrics_json_l.emplace_back (metrics.get ("block_count"), metrics.get ("cemented_count"), metrics.get ("unchecked_count"), metrics.get ("account_count"), metrics.get ("bandwidth_cap"), metrics.get ("peer_count"), metrics.get ("protocol_version"), metrics.get ("uptime"), metrics.get ("genesis_block"), metrics.get ("major_version"), metrics.get ("minor_version"), metrics.get ("patch_version"), metrics.get ("pre_release_version"), metrics.get ("maker")); } ASSERT_EQ (1, raw_metrics_json_l.size ()); @@ -8025,7 +8033,11 @@ TEST (rpc, node_telemetry_random) ASSERT_EQ (node->config.bandwidth_limit, std::get<4> (metrics)); ASSERT_EQ (1, std::get<5> (metrics)); ASSERT_EQ (node->network_params.protocol.protocol_version, std::get<6> (metrics)); - ASSERT_EQ (nano::get_major_node_version (), std::get<7> (metrics)); - ASSERT_GE (100, std::get<8> (metrics)); - ASSERT_EQ (nano::genesis ().hash ().to_string (), std::get<9> (metrics)); + ASSERT_GE (100, std::get<7> (metrics)); + ASSERT_EQ (nano::genesis ().hash ().to_string (), std::get<8> (metrics)); + ASSERT_EQ (nano::get_major_node_version (), std::get<9> (metrics)); + ASSERT_EQ (nano::get_minor_node_version (), std::get<10> (metrics)); + ASSERT_EQ (nano::get_patch_node_version (), std::get<11> (metrics)); + ASSERT_EQ (nano::get_pre_release_node_version (), std::get<12> (metrics)); + ASSERT_EQ (0, std::get<13> (metrics)); }