monero-project/monero
monero-project/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-11-17 16:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #6875

Browse source 
a12a8174e Dandelion++: skip desynced peers in stem phase (xiphon)
This commit is contained in:
Alexander Blair 2020-10-18 23:25:08 -07:00
commit 543d600042
No known key found for this signature in database
GPG key ID: C64552D877C32479
9 changed files with 78 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/cryptonote_core/cryptonote_core.h
View file

@ -663,7 +663,7 @@ namespace cryptonote
* *
* @param target_blockchain_height the target height * @param target_blockchain_height the target height
*/ */
uint64_t get_target_blockchain_height() const; virtual uint64_t get_target_blockchain_height() const override;
/** /**
* @brief returns the newest hardfork version known to the blockchain * @brief returns the newest hardfork version known to the blockchain

1
src/cryptonote_core/i_core_events.h
View file

@ -39,6 +39,7 @@ namespace cryptonote
virtual ~i_core_events() noexcept virtual ~i_core_events() noexcept
{} {}
virtual uint64_t get_target_blockchain_height() const = 0;
virtual void on_transactions_relayed(epee::span<const cryptonote::blobdata> tx_blobs, relay_method tx_relay) = 0; virtual void on_transactions_relayed(epee::span<const cryptonote::blobdata> tx_blobs, relay_method tx_relay) = 0;
}; };
} }

2
src/cryptonote_protocol/cryptonote_protocol_handler.inl
View file

@ -2538,7 +2538,7 @@ skip:
local mempool before doing the relay. The code was already updating the local mempool before doing the relay. The code was already updating the
DB twice on received transactions - it is difficult to workaround this DB twice on received transactions - it is difficult to workaround this
due to the internal design. */ due to the internal design. */
return m_p2p->send_txs(std::move(arg.txs), zone, source, m_core, tx_relay) != epee::net_utils::zone::invalid; return m_p2p->send_txs(std::move(arg.txs), zone, source, tx_relay) != epee::net_utils::zone::invalid;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>

40
src/cryptonote_protocol/levin_notify.cpp
View file

@ -105,8 +105,8 @@ namespace levin
return std::chrono::steady_clock::duration{crypto::rand_range(rep(0), range.count())}; return std::chrono::steady_clock::duration{crypto::rand_range(rep(0), range.count())};
} }
//! \return All outgoing connections supporting fragments in `connections`. //! \return Outgoing connections supporting fragments in `connections` filtered by remote blockchain height.
std::vector<boost::uuids::uuid> get_out_connections(connections& p2p) std::vector<boost::uuids::uuid> get_out_connections(connections& p2p, uint64_t min_blockchain_height)
{ {
std::vector<boost::uuids::uuid> outs; std::vector<boost::uuids::uuid> outs;
outs.reserve(connection_id_reserve_size); outs.reserve(connection_id_reserve_size);
@ -115,8 +115,8 @@ namespace levin
the reserve call so a strand is not used. Investigate if there is lots the reserve call so a strand is not used. Investigate if there is lots
of waiting in here. */ of waiting in here. */
p2p.foreach_connection([&outs] (detail::p2p_context& context) { p2p.foreach_connection([&outs, min_blockchain_height] (detail::p2p_context& context) {
if (!context.m_is_income) if (!context.m_is_income && context.m_remote_blockchain_height >= min_blockchain_height)
outs.emplace_back(context.m_connection_id); outs.emplace_back(context.m_connection_id);
return true; return true;
}); });
@ -544,7 +544,7 @@ namespace levin
} }
// connection list may be outdated, try again // connection list may be outdated, try again
update_channels::run(zone_, get_out_connections(*zone_->p2p)); update_channels::run(zone_, get_out_connections(*zone_->p2p, core_->get_target_blockchain_height()));
} }
MERROR("Unable to send transaction(s) via Dandelion++ stem"); MERROR("Unable to send transaction(s) via Dandelion++ stem");
@ -591,8 +591,9 @@ namespace levin
{ {
std::shared_ptr<detail::zone> zone_; std::shared_ptr<detail::zone> zone_;
const std::size_t channel_; const std::size_t channel_;
const i_core_events* core_;
static void wait(const std::chrono::steady_clock::time_point start, std::shared_ptr<detail::zone> zone, const std::size_t index) static void wait(const std::chrono::steady_clock::time_point start, std::shared_ptr<detail::zone> zone, const std::size_t index, const i_core_events* core)
{ {
if (!zone) if (!zone)
return; return;
@ -600,7 +601,7 @@ namespace levin
noise_channel& channel = zone->channels.at(index); noise_channel& channel = zone->channels.at(index);
channel.next_noise.expires_at(start + noise_min_delay + random_duration(noise_delay_range)); channel.next_noise.expires_at(start + noise_min_delay + random_duration(noise_delay_range));
channel.next_noise.async_wait( channel.next_noise.async_wait(
channel.strand.wrap(send_noise{std::move(zone), index}) channel.strand.wrap(send_noise{std::move(zone), index, core})
); );
} }
@ -645,7 +646,7 @@ namespace levin
channel.active = nullptr; channel.active = nullptr;
channel.connection = boost::uuids::nil_uuid(); channel.connection = boost::uuids::nil_uuid();
auto connections = get_out_connections(*zone_->p2p); auto connections = get_out_connections(*zone_->p2p, core_->get_target_blockchain_height());
if (connections.empty()) if (connections.empty())
MWARNING("Lost all outbound connections to anonymity network - currently unable to send transaction(s)"); MWARNING("Lost all outbound connections to anonymity network - currently unable to send transaction(s)");
@ -653,7 +654,7 @@ namespace levin
} }
} }
wait(start, std::move(zone_), channel_); wait(start, std::move(zone_), channel_, core_);
} }
}; };
@ -665,6 +666,7 @@ namespace levin
std::chrono::seconds min_epoch_; std::chrono::seconds min_epoch_;
std::chrono::seconds epoch_range_; std::chrono::seconds epoch_range_;
std::size_t count_; std::size_t count_;
const i_core_events* core_;
//! \pre Should not be invoked within any strand to prevent blocking. //! \pre Should not be invoked within any strand to prevent blocking.
void operator()(const boost::system::error_code error = {}) void operator()(const boost::system::error_code error = {})
@ -677,8 +679,9 @@ namespace levin
const bool fluffing = crypto::rand_idx(unsigned(100)) < CRYPTONOTE_DANDELIONPP_FLUFF_PROBABILITY; const bool fluffing = crypto::rand_idx(unsigned(100)) < CRYPTONOTE_DANDELIONPP_FLUFF_PROBABILITY;
const auto start = std::chrono::steady_clock::now(); const auto start = std::chrono::steady_clock::now();
auto connections = get_out_connections(*(zone_->p2p), core_->get_target_blockchain_height());
zone_->strand.dispatch( zone_->strand.dispatch(
change_channels{zone_, net::dandelionpp::connection_map{get_out_connections(*(zone_->p2p)), count_}, fluffing} change_channels{zone_, net::dandelionpp::connection_map{std::move(connections), count_}, fluffing}
); );
detail::zone& alias = *zone_; detail::zone& alias = *zone_;
@ -688,8 +691,9 @@ namespace levin
}; };
} // anonymous } // anonymous
notify::notify(boost::asio::io_service& service, std::shared_ptr<connections> p2p, epee::byte_slice noise, const bool is_public, const bool pad_txs) notify::notify(boost::asio::io_service& service, std::shared_ptr<connections> p2p, epee::byte_slice noise, const bool is_public, const bool pad_txs, i_core_events& core)
: zone_(std::make_shared<detail::zone>(service, std::move(p2p), std::move(noise), is_public, pad_txs)) : zone_(std::make_shared<detail::zone>(service, std::move(p2p), std::move(noise), is_public, pad_txs))
, core_(std::addressof(core))
{ {
if (!zone_->p2p) if (!zone_->p2p)
throw std::logic_error{"cryptonote::levin::notify cannot have nullptr p2p argument"}; throw std::logic_error{"cryptonote::levin::notify cannot have nullptr p2p argument"};
@ -702,10 +706,10 @@ namespace levin
const auto epoch_range = noise_enabled ? noise_epoch_range : dandelionpp_epoch_range; const auto epoch_range = noise_enabled ? noise_epoch_range : dandelionpp_epoch_range;
const std::size_t out_count = noise_enabled ? CRYPTONOTE_NOISE_CHANNELS : CRYPTONOTE_DANDELIONPP_STEMS; const std::size_t out_count = noise_enabled ? CRYPTONOTE_NOISE_CHANNELS : CRYPTONOTE_DANDELIONPP_STEMS;
start_epoch{zone_, min_epoch, epoch_range, out_count}(); start_epoch{zone_, min_epoch, epoch_range, out_count, core_}();
for (std::size_t channel = 0; channel < zone_->channels.size(); ++channel) for (std::size_t channel = 0; channel < zone_->channels.size(); ++channel)
send_noise::wait(now, zone_, channel); send_noise::wait(now, zone_, channel, core_);
} }
} }
@ -726,7 +730,7 @@ namespace levin
return; return;
zone_->strand.dispatch( zone_->strand.dispatch(
update_channels{zone_, get_out_connections(*(zone_->p2p))} update_channels{zone_, get_out_connections(*(zone_->p2p), core_->get_target_blockchain_height())}
); );
} }
@ -753,7 +757,7 @@ namespace levin
zone_->flush_txs.cancel(); zone_->flush_txs.cancel();
} }
bool notify::send_txs(std::vector<blobdata> txs, const boost::uuids::uuid& source, i_core_events& core, relay_method tx_relay) bool notify::send_txs(std::vector<blobdata> txs, const boost::uuids::uuid& source, relay_method tx_relay)
{ {
if (txs.empty()) if (txs.empty())
return true; return true;
@ -785,7 +789,7 @@ namespace levin
tx_relay = relay_method::local; // do not put into stempool embargo (hopefully not there already!). tx_relay = relay_method::local; // do not put into stempool embargo (hopefully not there already!).
} }
core.on_transactions_relayed(epee::to_span(txs), tx_relay); core_->on_transactions_relayed(epee::to_span(txs), tx_relay);
// Padding is not useful when using noise mode. Send as stem so receiver // Padding is not useful when using noise mode. Send as stem so receiver
// forwards in Dandelion++ mode. // forwards in Dandelion++ mode.
@ -821,7 +825,7 @@ namespace levin
{ {
// this will change a local/forward tx to stem or fluff ... // this will change a local/forward tx to stem or fluff ...
zone_->strand.dispatch( zone_->strand.dispatch(
dandelionpp_notify{zone_, std::addressof(core), std::move(txs), source} dandelionpp_notify{zone_, core_, std::move(txs), source}
); );
break; break;
} }
@ -832,7 +836,7 @@ namespace levin
routine. A "fluff" over i2p/tor is not the same as a "fluff" over routine. A "fluff" over i2p/tor is not the same as a "fluff" over
ipv4/6. Marking it as "fluff" here will make the tx immediately ipv4/6. Marking it as "fluff" here will make the tx immediately
visible externally from this node, which is not desired. */ visible externally from this node, which is not desired. */
core.on_transactions_relayed(epee::to_span(txs), tx_relay); core_->on_transactions_relayed(epee::to_span(txs), tx_relay);
zone_->strand.dispatch(fluff_notify{zone_, std::move(txs), source}); zone_->strand.dispatch(fluff_notify{zone_, std::move(txs), source});
break; break;
} }

6
src/cryptonote_protocol/levin_notify.h
View file

@ -69,6 +69,7 @@ namespace levin
class notify class notify
{ {
std::shared_ptr<detail::zone> zone_; std::shared_ptr<detail::zone> zone_;
i_core_events* core_;
public: public:
struct status struct status
@ -80,10 +81,11 @@ namespace levin
//! Construct an instance that cannot notify. //! Construct an instance that cannot notify.
notify() noexcept notify() noexcept
: zone_(nullptr) : zone_(nullptr)
, core_(nullptr)
{} {}
//! Construct an instance with available notification `zones`. //! Construct an instance with available notification `zones`.
explicit notify(boost::asio::io_service& service, std::shared_ptr<connections> p2p, epee::byte_slice noise, bool is_public, bool pad_txs); explicit notify(boost::asio::io_service& service, std::shared_ptr<connections> p2p, epee::byte_slice noise, bool is_public, bool pad_txs, i_core_events& core);
notify(const notify&) = delete; notify(const notify&) = delete;
notify(notify&&) = default; notify(notify&&) = default;
@ -123,7 +125,7 @@ namespace levin
particular stem. particular stem.
\return True iff the notification is queued for sending. */ \return True iff the notification is queued for sending. */
bool send_txs(std::vector<blobdata> txs, const boost::uuids::uuid& source, i_core_events& core, relay_method tx_relay); bool send_txs(std::vector<blobdata> txs, const boost::uuids::uuid& source, relay_method tx_relay);
}; };
} // levin } // levin
} // net } // net

2
src/p2p/net_node.h
View file

@ -334,7 +334,7 @@ namespace nodetool
virtual void callback(p2p_connection_context& context); virtual void callback(p2p_connection_context& context);
//----------------- i_p2p_endpoint ------------------------------------------------------------- //----------------- i_p2p_endpoint -------------------------------------------------------------
virtual bool relay_notify_to_list(int command, const epee::span<const uint8_t> data_buff, std::vector<std::pair<epee::net_utils::zone, boost::uuids::uuid>> connections); virtual bool relay_notify_to_list(int command, const epee::span<const uint8_t> data_buff, std::vector<std::pair<epee::net_utils::zone, boost::uuids::uuid>> connections);
virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::i_core_events& core, cryptonote::relay_method tx_relay); virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::relay_method tx_relay);
virtual bool invoke_command_to_peer(int command, const epee::span<const uint8_t> req_buff, std::string& resp_buff, const epee::net_utils::connection_context_base& context); virtual bool invoke_command_to_peer(int command, const epee::span<const uint8_t> req_buff, std::string& resp_buff, const epee::net_utils::connection_context_base& context);
virtual bool invoke_notify_to_peer(int command, const epee::span<const uint8_t> req_buff, const epee::net_utils::connection_context_base& context); virtual bool invoke_notify_to_peer(int command, const epee::span<const uint8_t> req_buff, const epee::net_utils::connection_context_base& context);
virtual bool drop_connection(const epee::net_utils::connection_context_base& context); virtual bool drop_connection(const epee::net_utils::connection_context_base& context);

10
src/p2p/net_node.inl
View file

@ -386,7 +386,7 @@ namespace nodetool
m_use_ipv6 = command_line::get_arg(vm, arg_p2p_use_ipv6); m_use_ipv6 = command_line::get_arg(vm, arg_p2p_use_ipv6);
m_require_ipv4 = !command_line::get_arg(vm, arg_p2p_ignore_ipv4); m_require_ipv4 = !command_line::get_arg(vm, arg_p2p_ignore_ipv4);
public_zone.m_notifier = cryptonote::levin::notify{ public_zone.m_notifier = cryptonote::levin::notify{
public_zone.m_net_server.get_io_service(), public_zone.m_net_server.get_config_shared(), nullptr, true, pad_txs public_zone.m_net_server.get_io_service(), public_zone.m_net_server.get_config_shared(), nullptr, true, pad_txs, m_payload_handler.get_core()
}; };
if (command_line::has_arg(vm, arg_p2p_add_peer)) if (command_line::has_arg(vm, arg_p2p_add_peer))
@ -499,7 +499,7 @@ namespace nodetool
} }
zone.m_notifier = cryptonote::levin::notify{ zone.m_notifier = cryptonote::levin::notify{
zone.m_net_server.get_io_service(), zone.m_net_server.get_config_shared(), std::move(this_noise), false, pad_txs zone.m_net_server.get_io_service(), zone.m_net_server.get_config_shared(), std::move(this_noise), false, pad_txs, m_payload_handler.get_core()
}; };
} }
@ -1994,13 +1994,13 @@ namespace nodetool
} }
//----------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------
template<class t_payload_net_handler> template<class t_payload_net_handler>
epee::net_utils::zone node_server<t_payload_net_handler>::send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::i_core_events& core, const cryptonote::relay_method tx_relay) epee::net_utils::zone node_server<t_payload_net_handler>::send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, const cryptonote::relay_method tx_relay)
{ {
namespace enet = epee::net_utils; namespace enet = epee::net_utils;
const auto send = [&txs, &source, &core, tx_relay] (std::pair<const enet::zone, network_zone>& network) const auto send = [&txs, &source, tx_relay] (std::pair<const enet::zone, network_zone>& network)
{ {
if (network.second.m_notifier.send_txs(std::move(txs), source, core, tx_relay)) if (network.second.m_notifier.send_txs(std::move(txs), source, tx_relay))
return network.first; return network.first;
return enet::zone::invalid; return enet::zone::invalid;
}; };

4
src/p2p/net_node_common.h
View file

@ -50,7 +50,7 @@ namespace nodetool
struct i_p2p_endpoint struct i_p2p_endpoint
{ {
virtual bool relay_notify_to_list(int command, const epee::span<const uint8_t> data_buff, std::vector<std::pair<epee::net_utils::zone, boost::uuids::uuid>> connections)=0; virtual bool relay_notify_to_list(int command, const epee::span<const uint8_t> data_buff, std::vector<std::pair<epee::net_utils::zone, boost::uuids::uuid>> connections)=0;
virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::i_core_events& core, cryptonote::relay_method tx_relay)=0; virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::relay_method tx_relay)=0;
virtual bool invoke_command_to_peer(int command, const epee::span<const uint8_t> req_buff, std::string& resp_buff, const epee::net_utils::connection_context_base& context)=0; virtual bool invoke_command_to_peer(int command, const epee::span<const uint8_t> req_buff, std::string& resp_buff, const epee::net_utils::connection_context_base& context)=0;
virtual bool invoke_notify_to_peer(int command, const epee::span<const uint8_t> req_buff, const epee::net_utils::connection_context_base& context)=0; virtual bool invoke_notify_to_peer(int command, const epee::span<const uint8_t> req_buff, const epee::net_utils::connection_context_base& context)=0;
virtual bool drop_connection(const epee::net_utils::connection_context_base& context)=0; virtual bool drop_connection(const epee::net_utils::connection_context_base& context)=0;
@ -75,7 +75,7 @@ namespace nodetool
{ {
return false; return false;
} }
virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::i_core_events& core, cryptonote::relay_method tx_relay) virtual epee::net_utils::zone send_txs(std::vector<cryptonote::blobdata> txs, const epee::net_utils::zone origin, const boost::uuids::uuid& source, cryptonote::relay_method tx_relay)
{ {
return epee::net_utils::zone::invalid; return epee::net_utils::zone::invalid;
} }

75
tests/unit_tests/levin.cpp
View file

@ -120,6 +120,11 @@ namespace
{ {
std::map<cryptonote::relay_method, std::vector<cryptonote::blobdata>> relayed_; std::map<cryptonote::relay_method, std::vector<cryptonote::blobdata>> relayed_;
uint64_t get_target_blockchain_height() const override
{
return 0;
}
virtual void on_transactions_relayed(epee::span<const cryptonote::blobdata> txes, cryptonote::relay_method relay) override final virtual void on_transactions_relayed(epee::span<const cryptonote::blobdata> txes, cryptonote::relay_method relay) override final
{ {
std::vector<cryptonote::blobdata>& cached = relayed_[relay]; std::vector<cryptonote::blobdata>& cached = relayed_[relay];
@ -324,7 +329,7 @@ namespace
epee::byte_slice noise = nullptr; epee::byte_slice noise = nullptr;
if (noise_size) if (noise_size)
noise = epee::levin::make_noise_notify(noise_size); noise = epee::levin::make_noise_notify(noise_size);
return cryptonote::levin::notify{io_service_, connections_, std::move(noise), is_public, pad_txs}; return cryptonote::levin::notify{io_service_, connections_, std::move(noise), is_public, pad_txs, events_};
} }
boost::uuids::random_generator random_generator_; boost::uuids::random_generator random_generator_;
@ -483,11 +488,11 @@ TEST_F(levin_notify, defaulted)
EXPECT_FALSE(status.has_noise); EXPECT_FALSE(status.has_noise);
EXPECT_FALSE(status.connections_filled); EXPECT_FALSE(status.connections_filled);
} }
EXPECT_TRUE(notifier.send_txs({}, random_generator_(), events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs({}, random_generator_(), cryptonote::relay_method::local));
std::vector<cryptonote::blobdata> txs(2); std::vector<cryptonote::blobdata> txs(2);
txs[0].resize(100, 'e'); txs[0].resize(100, 'e');
EXPECT_FALSE(notifier.send_txs(std::move(txs), random_generator_(), events_, cryptonote::relay_method::local)); EXPECT_FALSE(notifier.send_txs(std::move(txs), random_generator_(), cryptonote::relay_method::local));
} }
TEST_F(levin_notify, fluff_without_padding) TEST_F(levin_notify, fluff_without_padding)
@ -512,7 +517,7 @@ TEST_F(levin_notify, fluff_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::fluff)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::fluff));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -564,7 +569,7 @@ TEST_F(levin_notify, stem_without_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -636,7 +641,7 @@ TEST_F(levin_notify, local_without_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::local));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -708,7 +713,7 @@ TEST_F(levin_notify, forward_without_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::forward)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::forward));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -727,7 +732,9 @@ TEST_F(levin_notify, forward_without_padding)
{ {
const std::size_t sent = context->process_send_queue(); const std::size_t sent = context->process_send_queue();
if (sent && is_stem) if (sent && is_stem)
{
EXPECT_EQ(1u, (context - contexts_.begin()) % 2); EXPECT_EQ(1u, (context - contexts_.begin()) % 2);
}
send_count += sent; send_count += sent;
} }
@ -772,7 +779,7 @@ TEST_F(levin_notify, block_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::block)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::block));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -801,7 +808,7 @@ TEST_F(levin_notify, none_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::none)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::none));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -830,7 +837,7 @@ TEST_F(levin_notify, fluff_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::fluff)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::fluff));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -879,7 +886,7 @@ TEST_F(levin_notify, stem_with_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -946,7 +953,7 @@ TEST_F(levin_notify, local_with_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::local));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1013,7 +1020,7 @@ TEST_F(levin_notify, forward_with_padding)
while (!has_stemmed || !has_fluffed) while (!has_stemmed || !has_fluffed)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::forward)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::forward));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1077,7 +1084,7 @@ TEST_F(levin_notify, block_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::block)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::block));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1106,7 +1113,7 @@ TEST_F(levin_notify, none_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::none)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::none));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1135,7 +1142,7 @@ TEST_F(levin_notify, private_fluff_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::fluff)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::fluff));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1186,7 +1193,7 @@ TEST_F(levin_notify, private_stem_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1237,7 +1244,7 @@ TEST_F(levin_notify, private_local_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::local));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1288,7 +1295,7 @@ TEST_F(levin_notify, private_forward_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::forward)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::forward));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1339,7 +1346,7 @@ TEST_F(levin_notify, private_block_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::block)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::block));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1369,7 +1376,7 @@ TEST_F(levin_notify, private_none_without_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::none)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::none));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1398,7 +1405,7 @@ TEST_F(levin_notify, private_fluff_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::fluff)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::fluff));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1448,7 +1455,7 @@ TEST_F(levin_notify, private_stem_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1498,7 +1505,7 @@ TEST_F(levin_notify, private_local_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::local));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1548,7 +1555,7 @@ TEST_F(levin_notify, private_forward_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::forward)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::forward));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1598,7 +1605,7 @@ TEST_F(levin_notify, private_block_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::block)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::block));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1627,7 +1634,7 @@ TEST_F(levin_notify, private_none_with_padding)
ASSERT_EQ(10u, contexts_.size()); ASSERT_EQ(10u, contexts_.size());
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::none)); EXPECT_FALSE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::none));
io_service_.reset(); io_service_.reset();
ASSERT_EQ(0u, io_service_.poll()); ASSERT_EQ(0u, io_service_.poll());
@ -1659,7 +1666,7 @@ TEST_F(levin_notify, stem_mappings)
for (;;) for (;;)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1721,7 +1728,7 @@ TEST_F(levin_notify, stem_mappings)
for (unsigned i = 0; i < contexts_.size() * 2; i += 2) for (unsigned i = 0; i < contexts_.size() * 2; i += 2)
{ {
auto& incoming = contexts_[i % contexts_.size()]; auto& incoming = contexts_[i % contexts_.size()];
EXPECT_TRUE(notifier.send_txs(txs, incoming.get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, incoming.get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1782,7 +1789,7 @@ TEST_F(levin_notify, fluff_multiple)
for (;;) for (;;)
{ {
auto context = contexts_.begin(); auto context = contexts_.begin();
EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, context->get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1841,7 +1848,7 @@ TEST_F(levin_notify, fluff_multiple)
for (unsigned i = 0; i < contexts_.size() * 2; i += 2) for (unsigned i = 0; i < contexts_.size() * 2; i += 2)
{ {
auto& incoming = contexts_[i % contexts_.size()]; auto& incoming = contexts_[i % contexts_.size()];
EXPECT_TRUE(notifier.send_txs(txs, incoming.get_id(), events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, incoming.get_id(), cryptonote::relay_method::stem));
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1905,7 +1912,7 @@ TEST_F(levin_notify, noise)
EXPECT_EQ(0u, receiver_.notified_size()); EXPECT_EQ(0u, receiver_.notified_size());
} }
EXPECT_TRUE(notifier.send_txs(txs, incoming_id, events_, cryptonote::relay_method::local)); EXPECT_TRUE(notifier.send_txs(txs, incoming_id, cryptonote::relay_method::local));
notifier.run_stems(); notifier.run_stems();
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1927,7 +1934,7 @@ TEST_F(levin_notify, noise)
} }
txs[0].resize(3000, 'r'); txs[0].resize(3000, 'r');
EXPECT_TRUE(notifier.send_txs(txs, incoming_id, events_, cryptonote::relay_method::fluff)); EXPECT_TRUE(notifier.send_txs(txs, incoming_id, cryptonote::relay_method::fluff));
notifier.run_stems(); notifier.run_stems();
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());
@ -1996,7 +2003,7 @@ TEST_F(levin_notify, noise_stem)
EXPECT_EQ(0u, receiver_.notified_size()); EXPECT_EQ(0u, receiver_.notified_size());
} }
EXPECT_TRUE(notifier.send_txs(txs, incoming_id, events_, cryptonote::relay_method::stem)); EXPECT_TRUE(notifier.send_txs(txs, incoming_id, cryptonote::relay_method::stem));
notifier.run_stems(); notifier.run_stems();
io_service_.reset(); io_service_.reset();
ASSERT_LT(0u, io_service_.poll()); ASSERT_LT(0u, io_service_.poll());