Logic_test.cpp

#include <test/unit_test/SuiteJournal.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/random.h>
#include <xrpl/beast/insight/NullCollector.h>
#include <xrpl/beast/net/IPAddressV4.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/resource/Charge.h>
#include <xrpl/resource/Consumer.h>
#include <xrpl/resource/Disposition.h>
#include <xrpl/resource/Gossip.h>
#include <xrpl/resource/detail/Logic.h>
#include <xrpl/resource/detail/Tuning.h>
 
#include <boost/utility/base_from_member.hpp>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <string>
 
namespace xrpl::Resource {
 
class ResourceManager_test : public beast::unit_test::Suite
{
public:
    class TestLogic : private boost::base_from_member<TestStopwatch>, public Logic
 
    {
    private:
        using clock_type = boost::base_from_member<TestStopwatch>;
 
    public:
        explicit TestLogic(beast::Journal journal)
            : Logic(beast::insight::NullCollector::make(), member, journal)
        {
        }
 
        void
        advance()
        {
            ++member;
        }
 
        TestStopwatch&
        clock()
        {
            return member;
        }
    };
 
    //--------------------------------------------------------------------------
 
    static void
    createGossip(Gossip& gossip)
    {
        std::uint8_t const v(10 + randInt(9));
        std::uint8_t const n(10 + randInt(9));
        gossip.items.reserve(n);
        for (std::uint8_t i = 0; i < n; ++i)
        {
            Gossip::Item item;
            item.balance = 100 + randInt(499);
            beast::IP::AddressV4::bytes_type const d = {
                {192, 0, 2, static_cast<std::uint8_t>(v + i)}};
            item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
            gossip.items.push_back(item);
        }
    }
 
    //--------------------------------------------------------------------------
 
    void
    testDrop(beast::Journal j, bool limited)
    {
        if (limited)
        {
            testcase("Limited warn/drop");
        }
        else
        {
            testcase("Unlimited warn/drop");
        }
 
        TestLogic logic(j);
 
        Charge const fee(kDropThreshold + 1);
        beast::IP::Endpoint const addr(beast::IP::Endpoint::fromString("192.0.2.2"));
 
        std::function<Consumer(beast::IP::Endpoint)> const ep = limited
            ? std::bind(&TestLogic::newInboundEndpoint, &logic, std::placeholders::_1)
            : std::bind(&TestLogic::newUnlimitedEndpoint, &logic, std::placeholders::_1);
 
        {
            Consumer c(ep(addr));
 
            // Create load until we get a warning
            int n = 10000;
 
            while (--n >= 0)
            {
                if (n == 0)
                {
                    if (limited)
                    {
                        fail("Loop count exceeded without warning");
                    }
                    else
                    {
                        pass();
                    }
                    return;
                }
 
                if (c.charge(fee) == Disposition::Warn)
                {
                    if (limited)
                    {
                        pass();
                    }
                    else
                    {
                        fail("Should loop forever with no warning");
                    }
                    break;
                }
                ++logic.clock();
            }
 
            // Create load until we get dropped
            while (--n >= 0)
            {
                if (n == 0)
                {
                    if (limited)
                    {
                        fail("Loop count exceeded without dropping");
                    }
                    else
                    {
                        pass();
                    }
                    return;
                }
 
                if (c.charge(fee) == Disposition::Drop)
                {
                    // Disconnect abusive Consumer
                    BEAST_EXPECT(c.disconnect(j) == limited);
                    break;
                }
                ++logic.clock();
            }
        }
 
        // Make sure the consumer is on the blacklist for a while.
        {
            Consumer const c(logic.newInboundEndpoint(addr));
            logic.periodicActivity();
            if (c.disposition() != Disposition::Drop)
            {
                if (limited)
                {
                    fail("Dropped consumer not put on blacklist");
                }
                else
                {
                    pass();
                }
                return;
            }
        }
 
        // Makes sure the Consumer is eventually removed from blacklist
        bool readmitted = false;
        {
            using namespace std::chrono_literals;
            // Give Consumer time to become readmitted.  Should never
            // exceed expiration time.
            auto n = kSecondsUntilExpiration + 1s;
            while (--n > 0s)
            {
                ++logic.clock();
                logic.periodicActivity();
                Consumer const c(logic.newInboundEndpoint(addr));
                if (c.disposition() != Disposition::Drop)
                {
                    readmitted = true;
                    break;
                }
            }
        }
        if (!readmitted)
        {
            fail("Dropped Consumer left on blacklist too long");
            return;
        }
        pass();
    }
 
    void
    testImports(beast::Journal j)
    {
        testcase("Imports");
 
        TestLogic logic(j);
 
        Gossip g[5];
 
        for (int i = 0; i < 5; ++i)
            createGossip(g[i]);
 
        for (int i = 0; i < 5; ++i)
            logic.importConsumers(std::to_string(i), g[i]);
 
        pass();
    }
 
    void
    testImport(beast::Journal j)
    {
        testcase("Import");
 
        TestLogic logic(j);
 
        Gossip g;
        Gossip::Item item;
        item.balance = 100;
        beast::IP::AddressV4::bytes_type const d = {{192, 0, 2, 1}};
        item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
        g.items.push_back(item);
 
        logic.importConsumers("g", g);
 
        pass();
    }
 
    void
    testCharges(beast::Journal j)
    {
        testcase("Charge");
 
        TestLogic logic(j);
 
        {
            beast::IP::Endpoint const address(beast::IP::Endpoint::fromString("192.0.2.1"));
            Consumer c(logic.newInboundEndpoint(address));
            Charge const fee(1000);
            JLOG(j.info()) << "Charging " << c.toString() << " " << fee << " per second";
            c.charge(fee);
            for (int i = 0; i < 128; ++i)
            {
                JLOG(j.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
                               << ", Balance = " << c.balance();
                logic.advance();
            }
        }
 
        {
            beast::IP::Endpoint const address(beast::IP::Endpoint::fromString("192.0.2.2"));
            Consumer c(logic.newInboundEndpoint(address));
            Charge const fee(1000);
            JLOG(j.info()) << "Charging " << c.toString() << " " << fee << " per second";
            for (int i = 0; i < 128; ++i)
            {
                c.charge(fee);
                JLOG(j.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
                               << ", Balance = " << c.balance();
                logic.advance();
            }
        }
 
        pass();
    }
 
    void
    run() override
    {
        using beast::Severity;
        test::SuiteJournal journal("ResourceManager_test", *this);
 
        testDrop(journal, true);
        testDrop(journal, false);
        testCharges(journal);
        testImports(journal);
        testImport(journal);
    }
};
 
BEAST_DEFINE_TESTSUITE(ResourceManager, resource, xrpl);
 
}  // namespace xrpl::Resource