tx_reduce_relay_test.cpp

#include <test/jtx/Env.h>
#include <test/jtx/noop.h>
#include <test/overlay/CapturePeer.h>
 
#include <xrpld/app/main/Application.h>
#include <xrpld/core/Config.h>
#include <xrpld/overlay/Peer.h>
#include <xrpld/overlay/detail/Handshake.h>
#include <xrpld/overlay/detail/OverlayImpl.h>
#include <xrpld/overlay/detail/PeerImp.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/server/Handoff.h>
 
#include <xrpl.pb.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
namespace xrpl::test {
 
class tx_reduce_relay_test : public beast::unit_test::Suite
{
    void
    doTest(std::string const& msg, bool log, std::function<void(bool)> f)
    {
        testcase(msg);
        f(log);
    }
 
    void
    testConfig(bool log)
    {
        doTest("Config Test", log, [&](bool log) {
            auto test = [&](bool enable,
                            bool metrics,
                            std::uint16_t min,
                            std::uint16_t pct,
                            bool success = true) {
                std::stringstream str("[reduce_relay]");
                str << "[reduce_relay]\n"
                    << "tx_enable=" << static_cast<int>(enable) << "\n"
                    << "tx_metrics=" << static_cast<int>(metrics) << "\n"
                    << "tx_min_peers=" << min << "\n"
                    << "tx_relay_percentage=" << pct << "\n";
                Config c;
                try
                {
                    c.loadFromString(str.str());
 
                    BEAST_EXPECT(c.txReduceRelayEnable == enable);
                    BEAST_EXPECT(c.txReduceRelayMetrics == metrics);
                    BEAST_EXPECT(c.txReduceRelayMinPeers == min);
                    BEAST_EXPECT(c.txRelayPercentage == pct);
                    if (success)
                    {
                        pass();
                    }
                    else
                    {
                        fail();
                    }
                }
                catch (...)
                {
                    if (success)
                    {
                        fail();
                    }
                    else
                    {
                        pass();
                    }
                }
            };
 
            test(true, true, 20, 25);
            test(false, false, 20, 25);
            test(false, false, 20, 0, false);
            test(false, false, 20, 101, false);
            test(false, false, 9, 10, false);
            test(false, false, 10, 9, false);
        });
    }

    class TxReducePeer : public CapturePeer
    {
    public:
        using CapturePeer::CapturePeer;
 
        void
        addTxQueue(UInt256 const&) override
        {
            ++queued_;
        }

        std::size_t
        queued() const
        {
            return queued_;
        }
 
    private:
        std::size_t queued_{0};
    };

    void
    addPeer(
        jtx::Env& env,
        std::vector<std::shared_ptr<TxReducePeer>>& peers,
        std::uint16_t& nDisabled)
    {
        auto& overlay = dynamic_cast<OverlayImpl&>(env.app().getOverlay());
        PublicKey const key(std::get<0>(randomKeyPair(KeyType::Ed25519)));
 
        bool const disabled = nDisabled > 0;
        if (disabled)
            --nDisabled;
 
        HttpRequestType request;
        if (!disabled)
            request.insert("X-Protocol-Ctl", makeFeaturesRequestHeader(false, false, true, false));
 
        BEAST_EXPECT(overlay.findPeerByPublicKey(key) == std::shared_ptr<PeerImp>{});
        auto const peer = makeCapturePeer<TxReducePeer>(env, key, std::move(request));
        BEAST_EXPECT(overlay.findPeerByPublicKey(key) == peer);
        peers.emplace_back(peer);
    }

    void
    testRelay(
        std::string const& test,
        bool txRREnabled,
        std::uint16_t nPeers,
        std::uint16_t nDisabled,
        std::uint16_t minPeers,
        std::uint16_t relayPercentage,
        std::uint16_t expectRelay,
        std::uint16_t expectQueue,
        std::size_t nSkip = 0)
    {
        testcase(test);
        jtx::Env env(*this);
        std::vector<std::shared_ptr<TxReducePeer>> peers;
        // `PeerImp` decides `txReduceRelayEnabled()` in its constructor, from
        // the config and the handshake header, so set these first.
        env.app().config().txReduceRelayEnable = txRREnabled;
        env.app().config().txReduceRelayMinPeers = minPeers;
        env.app().config().txRelayPercentage = relayPercentage;
        for (int i = 0; i < nPeers; i++)
            addPeer(env, peers, nDisabled);
 
        // An under-filled skip set would also fail the relay counts below, for
        // a reason that looks unrelated.
        if (!BEAST_EXPECT(nSkip <= peers.size()))
            return;
 
        // Skip the peers built first, so the skip set overlaps the disabled
        // peers as the expected counts assume.
        std::set<Peer::ID> toSkip;
        for (std::size_t i = 0; i < nSkip; ++i)
            toSkip.insert(peers[i]->id());
 
        auto const jtx = env.jt(noop(env.master));
        if (BEAST_EXPECT(jtx.stx))
        {
            protocol::TMTransaction m;
            Serializer s;
            jtx.stx->add(s);
            m.set_rawtransaction(s.data(), s.size());
            m.set_deferred(false);
            m.set_status(protocol::TransactionStatus::tsNEW);
            env.app().getOverlay().relay(UInt256{0}, m, toSkip);
 
            std::size_t sendTx = 0;
            std::size_t queueTx = 0;
            for (auto const& peer : peers)
            {
                sendTx += peer->sent().size();
                queueTx += peer->queued();
            }
            BEAST_EXPECT(sendTx == expectRelay && queueTx == expectQueue);
        }
    }

    void
    testQueueOnly(
        std::string const& test,
        bool txRREnabled,
        std::uint16_t nPeers,
        std::uint16_t nDisabled,
        std::uint16_t expectQueue)
    {
        testcase(test);
        jtx::Env env(*this);
        std::vector<std::shared_ptr<TxReducePeer>> peers;
        // `PeerImp` decides `txReduceRelayEnabled()` in its constructor, from
        // the config and the handshake header, so set this first.
        env.app().config().txReduceRelayEnable = txRREnabled;
        for (int i = 0; i < nPeers; i++)
            addPeer(env, peers, nDisabled);
 
        env.app().getOverlay().relay(uint256{0}, std::nullopt, {});
 
        std::size_t sendTx = 0;
        std::size_t queueTx = 0;
        for (auto const& peer : peers)
        {
            sendTx += peer->sent().size();
            queueTx += peer->queued();
        }
        BEAST_EXPECT(sendTx == 0 && queueTx == expectQueue);
    }
 
    void
    run() override
    {
        bool const log = false;
        testConfig(log);
        // relay to all peers, no hash queue
        testRelay("feature disabled", false, 10, 0, 10, 25, 10, 0);
        // relay to nPeers - skip (10-5=5)
        testRelay("feature disabled & skip", false, 10, 0, 10, 25, 5, 0, 5);
        // relay to all peers because min is greater than nPeers
        testRelay("relay all 1", true, 10, 0, 20, 25, 10, 0);
        // relay to all peers because min + disabled is greater thant nPeers
        testRelay("relay all 2", true, 20, 15, 10, 25, 20, 0);
        // relay to minPeers + 25% of nPeers-minPeers (20+0.25*(60-20)=30),
        // queue the rest (30)
        testRelay("relay & queue", true, 60, 0, 20, 25, 30, 30);
        // relay to minPeers + 25% of (nPeers - nPeers) - skip
        // (20+0.25*(60-20)-5=25), queue the rest, skip counts towards relayed
        // (60-25-5=30)
        testRelay("skip", true, 60, 0, 20, 25, 25, 30, 5);
        // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
        // (20+10+0.25*(70-20-10)=40), queue the rest (30)
        testRelay("disabled", true, 70, 10, 20, 25, 40, 30);
        // relay to minPeers + disabled-not-in-skip + 25% of (nPeers - minPeers
        // - disabled) (20+5+0.25*(70-20-10)=35), queue the rest, skip counts
        // towards relayed (70-35-5=30))
        testRelay("disabled & skip", true, 70, 10, 20, 25, 35, 30, 5);
        // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
        // - skip (10+5+0.25*(15-10-5)-10=5), queue the rest, skip counts
        // towards relayed (15-5-10=0)
        testRelay("disabled & skip, no queue", true, 15, 5, 10, 25, 5, 0, 10);
        // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
        // - skip (10+2+0.25*(20-10-2)-14=0), queue the rest, skip counts
        // towards relayed (20-14=6)
        testRelay("disabled & skip, no relay", true, 20, 2, 10, 25, 0, 6, 14);
        // nothing to send, so nothing is queued either
        testQueueOnly("queue only, feature disabled", false, 10, 0, 0);
        // queue every peer, since all of them negotiated the feature
        testQueueOnly("queue only", true, 10, 0, 10);
        // queue the 6 that negotiated it and none of the 4 that did not
        testQueueOnly("queue only, some disabled", true, 10, 4, 6);
        // queue nobody, since no peer would understand the announcement
        testQueueOnly("queue only, all disabled", true, 10, 10, 0);
    }
};
 
BEAST_DEFINE_TESTSUITE(tx_reduce_relay, overlay, xrpl);
}  // namespace xrpl::test