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
This commit is contained in:
Wesley Shillingford
GitHub
parent
a29d7fac93
commit
033d8b5043
9 changed files with 260 additions and 44 deletions
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<nano::telemetry_data> 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<nano::telemetry_data> 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<uint8_t> ("minor_version").is_initialized ());
|
||||
ASSERT_FALSE (config1.get_optional<uint8_t> ("patch_version").is_initialized ());
|
||||
ASSERT_FALSE (config1.get_optional<uint8_t> ("pre_release_version").is_initialized ());
|
||||
ASSERT_FALSE (config1.get_optional<uint8_t> ("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 ());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -13,6 +13,18 @@ uint8_t get_major_node_version ()
|
|||
{
|
||||
return boost::numeric_cast<uint8_t> (boost::lexical_cast<int> (NANO_MAJOR_VERSION_STRING));
|
||||
}
|
||||
uint8_t get_minor_node_version ()
|
||||
{
|
||||
return boost::numeric_cast<uint8_t> (boost::lexical_cast<int> (NANO_MINOR_VERSION_STRING));
|
||||
}
|
||||
uint8_t get_patch_node_version ()
|
||||
{
|
||||
return boost::numeric_cast<uint8_t> (boost::lexical_cast<int> (NANO_PATCH_VERSION_STRING));
|
||||
}
|
||||
uint8_t get_pre_release_node_version ()
|
||||
{
|
||||
return boost::numeric_cast<uint8_t> (boost::lexical_cast<int> (NANO_PRE_RELEASE_VERSION_STRING));
|
||||
}
|
||||
|
||||
void force_nano_test_network ()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#include <nano/node/wallet.hpp>
|
||||
#include <nano/secure/buffer.hpp>
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
#include <boost/endian/conversion.hpp>
|
||||
#include <boost/pool/pool_alloc.hpp>
|
||||
#include <boost/variant/get.hpp>
|
||||
|
|
@ -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<nano::teleme
|
|||
nano::uint128_t bandwidth_sum{ 0 };
|
||||
|
||||
std::unordered_map<uint8_t, int> protocol_versions;
|
||||
std::unordered_map<uint8_t, int> vendor_versions;
|
||||
std::unordered_map<std::string, int> vendor_versions;
|
||||
std::unordered_map<uint64_t, int> bandwidth_caps;
|
||||
std::unordered_map<nano::block_hash, int> genesis_blocks;
|
||||
|
||||
|
|
@ -1190,8 +1208,28 @@ nano::telemetry_data nano::telemetry_data::consolidate (std::vector<nano::teleme
|
|||
account_sum += telemetry_data.account_count;
|
||||
block_sum += telemetry_data.block_count;
|
||||
cemented_sum += telemetry_data.cemented_count;
|
||||
++vendor_versions[telemetry_data.vendor_version];
|
||||
++protocol_versions[telemetry_data.protocol_version_number];
|
||||
|
||||
std::ostringstream ss;
|
||||
ss << telemetry_data.major_version;
|
||||
if (telemetry_data.minor_version.is_initialized ())
|
||||
{
|
||||
ss << "." << *telemetry_data.minor_version;
|
||||
if (telemetry_data.patch_version.is_initialized ())
|
||||
{
|
||||
ss << "." << *telemetry_data.patch_version;
|
||||
if (telemetry_data.pre_release_version.is_initialized ())
|
||||
{
|
||||
ss << "." << *telemetry_data.pre_release_version;
|
||||
if (telemetry_data.maker.is_initialized ())
|
||||
{
|
||||
ss << "." << *telemetry_data.maker;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
++vendor_versions[ss.str ()];
|
||||
++protocol_versions[telemetry_data.protocol_version];
|
||||
peer_sum += telemetry_data.peer_count;
|
||||
|
||||
// 0 has a special meaning (unlimited), don't include it in the average as it will be heavily skewed
|
||||
|
|
@ -1245,10 +1283,25 @@ nano::telemetry_data nano::telemetry_data::consolidate (std::vector<nano::teleme
|
|||
|
||||
// Use the mode of protocol version, vendor version and bandwidth cap if there is 2 or more using it
|
||||
set_mode_or_average (bandwidth_caps, consolidated_data.bandwidth_cap, bandwidth_sum, size);
|
||||
set_mode (protocol_versions, consolidated_data.protocol_version_number, size);
|
||||
set_mode (vendor_versions, consolidated_data.vendor_version, size);
|
||||
set_mode (protocol_versions, consolidated_data.protocol_version, size);
|
||||
set_mode (genesis_blocks, consolidated_data.genesis_block, size);
|
||||
|
||||
// Vendor version, needs to be parsed out of the string
|
||||
std::string version;
|
||||
set_mode (vendor_versions, version, size);
|
||||
|
||||
// May only have major version, but check for optional parameters as well, only output if all are used
|
||||
std::vector<std::string> 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<uint8_t> (version_fragments.front ());
|
||||
if (version_fragments.size () == 5)
|
||||
{
|
||||
consolidated_data.minor_version = boost::lexical_cast<uint8_t> (version_fragments[1]);
|
||||
consolidated_data.patch_version = boost::lexical_cast<uint8_t> (version_fragments[2]);
|
||||
consolidated_data.pre_release_version = boost::lexical_cast<uint8_t> (version_fragments[3]);
|
||||
consolidated_data.maker = boost::lexical_cast<uint8_t> (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<uint8_t> ("minor_version");
|
||||
patch_version = json.get_optional<uint8_t> ("patch_version");
|
||||
pre_release_version = json.get_optional<uint8_t> ("pre_release_version");
|
||||
maker = json.get_optional<uint8_t> ("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) :
|
||||
|
|
|
|||
|
|
@ -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<uint8_t> minor_version;
|
||||
boost::optional<uint8_t> patch_version;
|
||||
boost::optional<uint8_t> pre_release_version;
|
||||
boost::optional<uint8_t> maker; // 0 for NF node
|
||||
|
||||
static nano::telemetry_data consolidate (std::vector<nano::telemetry_data> 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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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::seconds> (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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7844,10 +7844,14 @@ void compare_default_test_result_data (test_response & response, nano::node cons
|
|||
ASSERT_EQ (1, response.json.get<uint64_t> ("account_count"));
|
||||
ASSERT_EQ (node_server_a.config.bandwidth_limit, response.json.get<uint64_t> ("bandwidth_cap"));
|
||||
ASSERT_EQ (1, response.json.get<uint32_t> ("peer_count"));
|
||||
ASSERT_EQ (node_server_a.network_params.protocol.protocol_version, response.json.get<uint8_t> ("protocol_version_number"));
|
||||
ASSERT_EQ (nano::get_major_node_version (), response.json.get<uint8_t> ("vendor_version"));
|
||||
ASSERT_EQ (node_server_a.network_params.protocol.protocol_version, response.json.get<uint8_t> ("protocol_version"));
|
||||
ASSERT_GE (100, response.json.get<uint64_t> ("uptime"));
|
||||
ASSERT_EQ (nano::genesis ().hash ().to_string (), response.json.get<std::string> ("genesis_block"));
|
||||
ASSERT_EQ (nano::get_major_node_version (), response.json.get<uint8_t> ("major_version"));
|
||||
ASSERT_EQ (nano::get_minor_node_version (), response.json.get<uint8_t> ("minor_version"));
|
||||
ASSERT_EQ (nano::get_patch_node_version (), response.json.get<uint8_t> ("patch_version"));
|
||||
ASSERT_EQ (nano::get_pre_release_node_version (), response.json.get<uint8_t> ("pre_release_version"));
|
||||
ASSERT_EQ (0, response.json.get<uint8_t> ("maker"));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -7990,10 +7994,14 @@ TEST (rpc, node_telemetry_random)
|
|||
ASSERT_EQ (1, response.json.get<uint64_t> ("account_count"));
|
||||
ASSERT_EQ (node->config.bandwidth_limit, response.json.get<uint64_t> ("bandwidth_cap"));
|
||||
ASSERT_EQ (1, response.json.get<uint32_t> ("peer_count"));
|
||||
ASSERT_EQ (node->network_params.protocol.protocol_version, response.json.get<uint8_t> ("protocol_version_number"));
|
||||
ASSERT_EQ (nano::get_major_node_version (), response.json.get<uint8_t> ("vendor_version"));
|
||||
ASSERT_EQ (node->network_params.protocol.protocol_version, response.json.get<uint8_t> ("protocol_version"));
|
||||
ASSERT_GE (100, response.json.get<uint64_t> ("uptime"));
|
||||
ASSERT_EQ (nano::genesis ().hash ().to_string (), response.json.get<std::string> ("genesis_block"));
|
||||
ASSERT_EQ (nano::get_major_node_version (), response.json.get<uint8_t> ("major_version"));
|
||||
ASSERT_EQ (nano::get_minor_node_version (), response.json.get<uint8_t> ("minor_version"));
|
||||
ASSERT_EQ (nano::get_patch_node_version (), response.json.get<uint8_t> ("patch_version"));
|
||||
ASSERT_EQ (nano::get_pre_release_node_version (), response.json.get<uint8_t> ("pre_release_version"));
|
||||
ASSERT_EQ (0, response.json.get<uint8_t> ("maker"));
|
||||
}
|
||||
|
||||
request.put ("raw", "true");
|
||||
|
|
@ -8009,11 +8017,11 @@ TEST (rpc, node_telemetry_random)
|
|||
ASSERT_TRUE (response.json.get<bool> ("cached"));
|
||||
|
||||
auto & all_metrics = response.json.get_child ("metrics");
|
||||
std::vector<std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint32_t, uint8_t, uint8_t, uint64_t, std::string>> raw_metrics_json_l;
|
||||
std::vector<std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint32_t, uint8_t, uint64_t, std::string, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t>> raw_metrics_json_l;
|
||||
for (auto & metrics_pair : all_metrics)
|
||||
{
|
||||
auto & metrics = metrics_pair.second;
|
||||
raw_metrics_json_l.emplace_back (metrics.get<uint64_t> ("block_count"), metrics.get<uint64_t> ("cemented_count"), metrics.get<uint64_t> ("unchecked_count"), metrics.get<uint64_t> ("account_count"), metrics.get<uint64_t> ("bandwidth_cap"), metrics.get<uint64_t> ("peer_count"), metrics.get<uint8_t> ("protocol_version_number"), metrics.get<uint8_t> ("vendor_version"), metrics.get<uint64_t> ("uptime"), metrics.get<std::string> ("genesis_block"));
|
||||
raw_metrics_json_l.emplace_back (metrics.get<uint64_t> ("block_count"), metrics.get<uint64_t> ("cemented_count"), metrics.get<uint64_t> ("unchecked_count"), metrics.get<uint64_t> ("account_count"), metrics.get<uint64_t> ("bandwidth_cap"), metrics.get<uint64_t> ("peer_count"), metrics.get<uint8_t> ("protocol_version"), metrics.get<uint64_t> ("uptime"), metrics.get<std::string> ("genesis_block"), metrics.get<uint8_t> ("major_version"), metrics.get<uint8_t> ("minor_version"), metrics.get<uint8_t> ("patch_version"), metrics.get<uint8_t> ("pre_release_version"), metrics.get<uint8_t> ("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));
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue