From b172d4d62fb0a1e5578b4892c635c36f1123940c Mon Sep 17 00:00:00 2001 From: Thiago Silva <82097354+thsfs@users.noreply.github.com> Date: Fri, 4 Jun 2021 09:22:37 -0300 Subject: [PATCH] Moves out peer methods from the block store class (#3318) * Moves out peer methods from the block store class --- nano/core_test/block_store.cpp | 32 +++++------ nano/core_test/ledger.cpp | 4 +- nano/core_test/node.cpp | 14 ++--- nano/nano_node/entry.cpp | 2 +- nano/node/cli.cpp | 4 +- nano/node/lmdb/lmdb.cpp | 6 +- nano/node/lmdb/lmdb.hpp | 2 +- nano/node/node.cpp | 4 +- nano/node/rocksdb/rocksdb.cpp | 4 +- nano/node/transport/tcp.cpp | 4 +- nano/node/transport/udp.cpp | 4 +- nano/rpc_test/rpc.cpp | 4 +- nano/secure/CMakeLists.txt | 1 + nano/secure/blockstore.cpp | 3 +- nano/secure/blockstore.hpp | 25 ++++++--- nano/secure/blockstore_partial.hpp | 44 ++------------- nano/secure/ledger.cpp | 6 +- nano/secure/store/peer_store_partial.hpp | 70 ++++++++++++++++++++++++ nano/test_common/testutil.cpp | 2 +- 19 files changed, 141 insertions(+), 94 deletions(-) create mode 100644 nano/secure/store/peer_store_partial.hpp diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 8d6804a1..0dbf306c 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1077,57 +1077,57 @@ TEST (block_store, peers) auto transaction (store->tx_begin_write ()); // Confirm that the store is empty - ASSERT_FALSE (store->peer_exists (transaction, endpoint)); - ASSERT_EQ (store->peer_count (transaction), 0); + ASSERT_FALSE (store->peer.exists (transaction, endpoint)); + ASSERT_EQ (store->peer.count (transaction), 0); // Add one - store->peer_put (transaction, endpoint); - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); + store->peer.put (transaction, endpoint); + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); } // Confirm that it can be found { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 1); + ASSERT_EQ (store->peer.count (transaction), 1); } // Add another one and check that it (and the existing one) can be found nano::endpoint_key endpoint1 (boost::asio::ip::address_v6::any ().to_bytes (), 101); { auto transaction (store->tx_begin_write ()); - store->peer_put (transaction, endpoint1); - ASSERT_TRUE (store->peer_exists (transaction, endpoint1)); // Check new peer is here - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); // Check first peer is still here + store->peer.put (transaction, endpoint1); + ASSERT_TRUE (store->peer.exists (transaction, endpoint1)); // Check new peer is here + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); // Check first peer is still here } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 2); + ASSERT_EQ (store->peer.count (transaction), 2); } // Delete the first one { auto transaction (store->tx_begin_write ()); - store->peer_del (transaction, endpoint1); - ASSERT_FALSE (store->peer_exists (transaction, endpoint1)); // Confirm it no longer exists - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); // Check first peer is still here + store->peer.del (transaction, endpoint1); + ASSERT_FALSE (store->peer.exists (transaction, endpoint1)); // Confirm it no longer exists + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); // Check first peer is still here } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 1); + ASSERT_EQ (store->peer.count (transaction), 1); } // Delete original one { auto transaction (store->tx_begin_write ()); - store->peer_del (transaction, endpoint); - ASSERT_FALSE (store->peer_exists (transaction, endpoint)); + store->peer.del (transaction, endpoint); + ASSERT_FALSE (store->peer.exists (transaction, endpoint)); } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 0); + ASSERT_EQ (store->peer.count (transaction), 0); } } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index b8e4e15a..9cda4e93 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -3864,7 +3864,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) 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.peer.put (transaction, endpoint_key); store.pending.put (transaction, nano::pending_key (nano::genesis_account, send->hash ()), nano::pending_info (nano::genesis_account, 100, nano::epoch::epoch_0)); store.pruned.put (transaction, send->hash ()); @@ -3895,7 +3895,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) auto block1 = rocksdb_store.block_get (rocksdb_transaction, send->hash ()); ASSERT_EQ (*send, *block1); - ASSERT_TRUE (rocksdb_store.peer_exists (rocksdb_transaction, endpoint_key)); + ASSERT_TRUE (rocksdb_store.peer.exists (rocksdb_transaction, endpoint_key)); 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; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 40f251c0..a2591d30 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -3577,10 +3577,10 @@ TEST (node, peers) { // Add a peer to the database auto transaction (store.tx_begin_write ()); - store.peer_put (transaction, endpoint_key); + store.peer.put (transaction, endpoint_key); // Add a peer which is not contactable - store.peer_put (transaction, nano::endpoint_key{ boost::asio::ip::address_v6::any ().to_bytes (), 55555 }); + store.peer.put (transaction, nano::endpoint_key{ boost::asio::ip::address_v6::any ().to_bytes (), 55555 }); } node2->start (); @@ -3605,8 +3605,8 @@ TEST (node, peers) // Uncontactable peer should not be stored auto transaction (store.tx_begin_read ()); - ASSERT_EQ (store.peer_count (transaction), 1); - ASSERT_TRUE (store.peer_exists (transaction, endpoint_key)); + ASSERT_EQ (store.peer.count (transaction), 1); + ASSERT_TRUE (store.peer.exists (transaction, endpoint_key)); node2->stop (); } @@ -3626,7 +3626,7 @@ TEST (node, peer_cache_restart) { // Add a peer to the database auto transaction (store.tx_begin_write ()); - store.peer_put (transaction, endpoint_key); + store.peer.put (transaction, endpoint_key); } node2->start (); ASSERT_TIMELY (10s, !node2->network.empty ()); @@ -3649,8 +3649,8 @@ TEST (node, peer_cache_restart) auto & store = node3->store; { auto transaction (store.tx_begin_read ()); - ASSERT_EQ (store.peer_count (transaction), 1); - ASSERT_TRUE (store.peer_exists (transaction, endpoint_key)); + ASSERT_EQ (store.peer.count (transaction), 1); + ASSERT_TRUE (store.peer.exists (transaction, endpoint_key)); } ASSERT_TIMELY (10s, !node3->network.empty ()); // Confirm that the peers match with the endpoints we are expecting diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 70e00365..da55dce8 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1865,7 +1865,7 @@ int main (int argc, char * const * argv) auto node = inactive_node->node; auto transaction (node->store.tx_begin_read ()); - for (auto i (node->store.peers_begin (transaction)), n (node->store.peers_end ()); i != n; ++i) + for (auto i (node->store.peer.begin (transaction)), n (node->store.peer.end ()); i != n; ++i) { std::cout << boost::str (boost::format ("%1%\n") % nano::endpoint (boost::asio::ip::address_v6 (i->first.address_bytes ()), i->first.port ())); } diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index cf5fd7ee..2c27183d 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -232,7 +232,7 @@ bool copy_database (boost::filesystem::path const & data_path, boost::program_op } if (vm.count ("peer_clear")) { - node.node->store.peer_clear (store.tx_begin_write ()); + node.node->store.peer.clear (store.tx_begin_write ()); } if (vm.count ("confirmation_height_clear")) { @@ -545,7 +545,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); - node.node->store.peer_clear (transaction); + node.node->store.peer.clear (transaction); std::cout << "Database peers are removed" << std::endl; } else diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp index 7ca124bd..a1427420 100644 --- a/nano/node/lmdb/lmdb.cpp +++ b/nano/node/lmdb/lmdb.cpp @@ -192,7 +192,7 @@ void nano::mdb_store::open_databases (bool & error_a, nano::transaction const & error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight_handle) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "meta", flags, &meta) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peers) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peer_handle) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "pruned", flags, &pruned_handle) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "confirmation_height", flags, &confirmation_height_handle) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts", flags, &accounts_v0) != 0; @@ -872,7 +872,7 @@ MDB_dbi nano::mdb_store::table_to_dbi (tables table_a) const case tables::meta: return meta; case tables::peers: - return peers; + return peer_handle; case tables::pruned: return pruned_handle; case tables::confirmation_height: @@ -881,7 +881,7 @@ MDB_dbi nano::mdb_store::table_to_dbi (tables table_a) const return final_vote_handle; default: release_assert (false); - return peers; + return peer_handle; } } diff --git a/nano/node/lmdb/lmdb.hpp b/nano/node/lmdb/lmdb.hpp index 604dc0ab..a586a36f 100644 --- a/nano/node/lmdb/lmdb.hpp +++ b/nano/node/lmdb/lmdb.hpp @@ -178,7 +178,7 @@ public: * Endpoints for peers * nano::endpoint_key -> no_value */ - MDB_dbi peers{ 0 }; + MDB_dbi peer_handle{ 0 }; /* * Confirmation height of an account, and the hash for the block at that height diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 05336c46..e8948808 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -765,7 +765,7 @@ void nano::node::long_inactivity_cleanup () if (perform_cleanup) { store.online_weight.clear (transaction); - store.peer_clear (transaction); + store.peer.clear (transaction); logger.always_log ("Removed records of peers and online weight after a long period of inactivity"); } } @@ -1206,7 +1206,7 @@ boost::optional nano::node::work_generate_blocking (nano::root const & void nano::node::add_initial_peers () { auto transaction (store.tx_begin_read ()); - for (auto i (store.peers_begin (transaction)), n (store.peers_end ()); i != n; ++i) + for (auto i (store.peer.begin (transaction)), n (store.peer.end ()); i != n; ++i) { nano::endpoint endpoint (boost::asio::ip::address_v6 (i->first.address_bytes ()), i->first.port ()); if (!network.reachout (endpoint, config.allow_local_peers)) diff --git a/nano/node/rocksdb/rocksdb.cpp b/nano/node/rocksdb/rocksdb.cpp index 03f8b85b..74b85789 100644 --- a/nano/node/rocksdb/rocksdb.cpp +++ b/nano/node/rocksdb/rocksdb.cpp @@ -483,7 +483,7 @@ uint64_t nano::rocksdb_store::count (nano::transaction const & transaction_a, ta // Peers/online weight are small enough that they can just be iterated to get accurate counts. if (table_a == tables::peers) { - for (auto i (peers_begin (transaction_a)), n (peers_end ()); i != n; ++i) + for (auto i (peer.begin (transaction_a)), n (peer.end ()); i != n; ++i) { ++sum; } @@ -557,7 +557,7 @@ int nano::rocksdb_store::drop (nano::write_transaction const & transaction_a, ta if (table_a == tables::peers) { int status = 0; - for (auto i = peers_begin (transaction_a), n = peers_end (); i != n; ++i) + for (auto i = peer.begin (transaction_a), n = peer.end (); i != n; ++i) { status = del (transaction_a, tables::peers, nano::rocksdb_val (i->first)); release_assert (success (status)); diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 68088052..47c45352 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -230,12 +230,12 @@ bool nano::transport::tcp_channels::store_all (bool clear_peers) auto transaction (node.store.tx_begin_write ({ tables::peers })); if (clear_peers) { - node.store.peer_clear (transaction); + node.store.peer.clear (transaction); } for (auto endpoint : endpoints) { nano::endpoint_key endpoint_key (endpoint.address ().to_v6 ().to_bytes (), endpoint.port ()); - node.store.peer_put (transaction, std::move (endpoint_key)); + node.store.peer.put (transaction, std::move (endpoint_key)); } result = true; } diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp index 0c06ecc1..9007eff1 100644 --- a/nano/node/transport/udp.cpp +++ b/nano/node/transport/udp.cpp @@ -202,12 +202,12 @@ bool nano::transport::udp_channels::store_all (bool clear_peers) auto transaction (node.store.tx_begin_write ({ tables::peers })); if (clear_peers) { - node.store.peer_clear (transaction); + node.store.peer.clear (transaction); } for (auto endpoint : endpoints) { nano::endpoint_key endpoint_key (endpoint.address ().to_v6 ().to_bytes (), endpoint.port ()); - node.store.peer_put (transaction, std::move (endpoint_key)); + node.store.peer.put (transaction, std::move (endpoint_key)); } result = true; } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index a761f002..da8fe13b 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -7655,7 +7655,7 @@ TEST (rpc, telemetry_single) // Wait until peers are stored as they are done in the background auto peers_stored = false; - ASSERT_TIMELY (10s, node1.store.peer_count (node1.store.tx_begin_read ()) != 0); + ASSERT_TIMELY (10s, node1.store.peer.count (node1.store.tx_begin_read ()) != 0); // Missing port boost::property_tree::ptree request; @@ -7731,7 +7731,7 @@ TEST (rpc, telemetry_all) rpc.start (); // Wait until peers are stored as they are done in the background - ASSERT_TIMELY (10s, node1.store.peer_count (node1.store.tx_begin_read ()) != 0); + ASSERT_TIMELY (10s, node1.store.peer.count (node1.store.tx_begin_read ()) != 0); // First need to set up the cached data std::atomic done{ false }; diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index 81ef22ca..b8468d22 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -59,6 +59,7 @@ add_library( store/pending_store_partial.hpp store/online_weight_partial.hpp store/pruned_store_partial.hpp + store/peer_store_partial.hpp store/confirmation_height_store_partial.hpp store/final_vote_store_partial.hpp) diff --git a/nano/secure/blockstore.cpp b/nano/secure/blockstore.cpp index bf8fd8f7..f20edab1 100644 --- a/nano/secure/blockstore.cpp +++ b/nano/secure/blockstore.cpp @@ -105,12 +105,13 @@ bool nano::write_transaction::contains (nano::tables table_a) const return impl->contains (table_a); } -nano::block_store::block_store (nano::frontier_store & frontier_store_a, nano::account_store & account_store_a, nano::pending_store & pending_store_a, nano::online_weight_store & online_weight_store_a, nano::pruned_store & pruned_store_a, nano::confirmation_height_store & confirmation_height_store_a, nano::final_vote_store & final_vote_store_a) : +nano::block_store::block_store (nano::frontier_store & frontier_store_a, nano::account_store & account_store_a, nano::pending_store & pending_store_a, nano::online_weight_store & online_weight_store_a, nano::pruned_store & pruned_store_a, nano::peer_store & peer_store_a, nano::confirmation_height_store & confirmation_height_store_a, nano::final_vote_store & final_vote_store_a) : frontier (frontier_store_a), account (account_store_a), pending (pending_store_a), online_weight (online_weight_store_a), pruned (pruned_store_a), + peer (peer_store_a), confirmation_height (confirmation_height_store_a), final_vote (final_vote_store_a) { diff --git a/nano/secure/blockstore.hpp b/nano/secure/blockstore.hpp index 3207f380..361c5f5f 100644 --- a/nano/secure/blockstore.hpp +++ b/nano/secure/blockstore.hpp @@ -670,6 +670,21 @@ public: virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; }; +/** + * Manages peer storage and iteration + */ +class peer_store +{ +public: + virtual void put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; + virtual void del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; + virtual bool exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const = 0; + virtual size_t count (nano::transaction const & transaction_a) const = 0; + virtual void clear (nano::write_transaction const & transaction_a) = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a) const = 0; + virtual nano::store_iterator end () const = 0; +}; + /** * Manages online weight storage and iteration */ @@ -746,7 +761,7 @@ public: class block_store { public: - explicit block_store (nano::frontier_store &, nano::account_store &, nano::pending_store &, nano::online_weight_store &, nano::pruned_store &, nano::confirmation_height_store &, nano::final_vote_store &); + explicit block_store (nano::frontier_store &, nano::account_store &, nano::pending_store &, nano::online_weight_store &, nano::pruned_store &, nano::peer_store &, nano::confirmation_height_store &, nano::final_vote_store &); virtual ~block_store () = default; virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::ledger_cache &) = 0; virtual void block_put (nano::write_transaction const &, nano::block_hash const &, nano::block const &) = 0; @@ -792,13 +807,7 @@ public: pruned_store & pruned; - virtual void peer_put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; - virtual void peer_del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; - virtual bool peer_exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const = 0; - virtual size_t peer_count (nano::transaction const & transaction_a) const = 0; - virtual void peer_clear (nano::write_transaction const & transaction_a) = 0; - virtual nano::store_iterator peers_begin (nano::transaction const & transaction_a) const = 0; - virtual nano::store_iterator peers_end () const = 0; + peer_store & peer; confirmation_height_store & confirmation_height; diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp index 92167946..5243d50d 100644 --- a/nano/secure/blockstore_partial.hpp +++ b/nano/secure/blockstore_partial.hpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -47,6 +48,7 @@ class block_store_partial : public block_store nano::pending_store_partial pending_store_partial; nano::online_weight_store_partial online_weight_store_partial; nano::pruned_store_partial pruned_store_partial; + nano::peer_store_partial peer_store_partial; nano::confirmation_height_store_partial confirmation_height_store_partial; nano::final_vote_store_partial final_vote_store_partial; @@ -62,16 +64,18 @@ public: friend class nano::pending_store_partial; friend class nano::online_weight_store_partial; friend class nano::pruned_store_partial; + friend class nano::peer_store_partial; friend class nano::confirmation_height_store_partial; friend class nano::final_vote_store_partial; block_store_partial () : - block_store{ frontier_store_partial, account_store_partial, pending_store_partial, online_weight_store_partial, pruned_store_partial, confirmation_height_store_partial, final_vote_store_partial }, + block_store{ frontier_store_partial, account_store_partial, pending_store_partial, online_weight_store_partial, pruned_store_partial, peer_store_partial, confirmation_height_store_partial, final_vote_store_partial }, frontier_store_partial{ *this }, account_store_partial{ *this }, pending_store_partial{ *this }, online_weight_store_partial{ *this }, pruned_store_partial{ *this }, + peer_store_partial{ *this }, confirmation_height_store_partial{ *this }, final_vote_store_partial{ *this } { @@ -249,11 +253,6 @@ public: return nano::store_iterator (nullptr); } - nano::store_iterator peers_end () const override - { - return nano::store_iterator (nullptr); - } - nano::store_iterator blocks_end () const override { return nano::store_iterator (nullptr); @@ -332,34 +331,6 @@ public: release_assert_success (*this, status); } - void peer_put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override - { - auto status = put_key (transaction_a, tables::peers, endpoint_a); - release_assert_success (*this, status); - } - - void peer_del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override - { - auto status (del (transaction_a, tables::peers, endpoint_a)); - release_assert_success (*this, status); - } - - bool peer_exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const override - { - return exists (transaction_a, tables::peers, nano::db_val (endpoint_a)); - } - - size_t peer_count (nano::transaction const & transaction_a) const override - { - return count (transaction_a, tables::peers); - } - - void peer_clear (nano::write_transaction const & transaction_a) override - { - auto status = drop (transaction_a, tables::peers); - release_assert_success (*this, status); - } - bool exists (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key_a) const { return static_cast (*this).exists (transaction_a, table_a, key_a); @@ -404,11 +375,6 @@ public: return make_iterator (transaction_a, tables::unchecked, nano::db_val (key_a)); } - nano::store_iterator peers_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::peers); - } - size_t unchecked_count (nano::transaction const & transaction_a) override { return count (transaction_a, tables::unchecked); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 5d68de7b..419eb472 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1509,14 +1509,14 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data rocksdb_store->online_weight.put (rocksdb_transaction, i->first, i->second); } - for (auto i (store.peers_begin (lmdb_transaction)), n (store.peers_end ()); i != n; ++i) + for (auto i (store.peer.begin (lmdb_transaction)), n (store.peer.end ()); i != n; ++i) { - rocksdb_store->peer_put (rocksdb_transaction, i->first); + rocksdb_store->peer.put (rocksdb_transaction, i->first); } // Compare counts error |= store.unchecked_count (lmdb_transaction) != rocksdb_store->unchecked_count (rocksdb_transaction); - error |= store.peer_count (lmdb_transaction) != rocksdb_store->peer_count (rocksdb_transaction); + error |= store.peer.count (lmdb_transaction) != rocksdb_store->peer.count (rocksdb_transaction); error |= store.pruned.count (lmdb_transaction) != rocksdb_store->pruned.count (rocksdb_transaction); error |= store.final_vote.count (lmdb_transaction) != rocksdb_store->final_vote.count (rocksdb_transaction); error |= store.online_weight.count (lmdb_transaction) != rocksdb_store->online_weight.count (rocksdb_transaction); diff --git a/nano/secure/store/peer_store_partial.hpp b/nano/secure/store/peer_store_partial.hpp new file mode 100644 index 00000000..f17c1a97 --- /dev/null +++ b/nano/secure/store/peer_store_partial.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class block_store_partial; + +template +void release_assert_success (block_store_partial const & block_store, const int status); + +template +class peer_store_partial : public peer_store +{ +private: + nano::block_store_partial & block_store; + + friend void release_assert_success (block_store_partial const & block_store, const int status); + +public: + explicit peer_store_partial (nano::block_store_partial & block_store_a) : + block_store (block_store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override + { + auto status = block_store.put_key (transaction_a, tables::peers, endpoint_a); + release_assert_success (block_store, status); + } + + void del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override + { + auto status (block_store.del (transaction_a, tables::peers, endpoint_a)); + release_assert_success (block_store, status); + } + + bool exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const override + { + return block_store.exists (transaction_a, tables::peers, nano::db_val (endpoint_a)); + } + + size_t count (nano::transaction const & transaction_a) const override + { + return block_store.count (transaction_a, tables::peers); + } + + void clear (nano::write_transaction const & transaction_a) override + { + auto status = block_store.drop (transaction_a, tables::peers); + release_assert_success (block_store, status); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return block_store.template make_iterator (transaction_a, tables::peers); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } +}; + +} diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index e1298b1d..194a85ad 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -41,7 +41,7 @@ void nano::wait_peer_connections (nano::system & system_a) else { auto transaction = node->store.tx_begin_read (); - return total += node->store.peer_count (transaction); + return total += node->store.peer.count (transaction); } }); }