Counts.h

#pragma once
 
#include <xrpld/peerfinder/PeerfinderManager.h>
#include <xrpld/peerfinder/Slot.h>
#include <xrpld/peerfinder/detail/Tuning.h>
 
#include <xrpl/basics/random.h>
 
namespace xrpl {
namespace PeerFinder {
 
class Counts
{
public:
    Counts()
        : m_attempts(0)
        , m_active(0)
        , m_in_max(0)
        , m_in_active(0)
        , m_out_max(0)
        , m_out_active(0)
        , m_fixed(0)
        , m_fixed_active(0)
        , m_reserved(0)
 
        , m_acceptCount(0)
        , m_closingCount(0)
    {
    }
 
    //--------------------------------------------------------------------------
 
    void
    add(Slot const& s)
    {
        adjust(s, 1);
    }
 
    void
    remove(Slot const& s)
    {
        adjust(s, -1);
    }
 
    bool
    can_activate(Slot const& s) const
    {
        // Must be handshaked and in the right state
        XRPL_ASSERT(
            s.state() == Slot::connected || s.state() == Slot::accept,
            "xrpl::PeerFinder::Counts::can_activate : valid input state");
 
        if (s.fixed() || s.reserved())
            return true;
 
        if (s.inbound())
            return m_in_active < m_in_max;
 
        return m_out_active < m_out_max;
    }
 
    std::size_t
    attempts_needed() const
    {
        if (m_attempts >= Tuning::maxConnectAttempts)
            return 0;
        return Tuning::maxConnectAttempts - m_attempts;
    }
 
    std::size_t
    attempts() const
    {
        return m_attempts;
    }
 
    int
    out_max() const
    {
        return m_out_max;
    }
 
    int
    out_active() const
    {
        return m_out_active;
    }
 
    std::size_t
    fixed() const
    {
        return m_fixed;
    }
 
    std::size_t
    fixed_active() const
    {
        return m_fixed_active;
    }
 
    //--------------------------------------------------------------------------
 
    void
    onConfig(Config const& config)
    {
        m_out_max = config.outPeers;
        if (config.wantIncoming)
            m_in_max = config.inPeers;
    }
 
    int
    acceptCount() const
    {
        return m_acceptCount;
    }
 
    int
    connectCount() const
    {
        return m_attempts;
    }
 
    int
    closingCount() const
    {
        return m_closingCount;
    }
 
    int
    in_max() const
    {
        return m_in_max;
    }
 
    int
    inboundActive() const
    {
        return m_in_active;
    }
 
    int
    totalActive() const
    {
        return m_in_active + m_out_active;
    }
 
    int
    inboundSlotsFree() const
    {
        if (m_in_active < m_in_max)
            return m_in_max - m_in_active;
        return 0;
    }
 
    int
    outboundSlotsFree() const
    {
        if (m_out_active < m_out_max)
            return m_out_max - m_out_active;
        return 0;
    }
 
    //--------------------------------------------------------------------------
 
    bool
    isConnectedToNetwork() const
    {
        // We will consider ourselves connected if we have reached
        // the number of outgoing connections desired, or if connect
        // automatically is false.
        //
        // Fixed peers do not count towards the active outgoing total.
 
        if (m_out_max > 0)
            return false;
 
        return true;
    }
 
    void
    onWrite(beast::PropertyStream::Map& map)
    {
        map["accept"] = acceptCount();
        map["connect"] = connectCount();
        map["close"] = closingCount();
        map["in"] << m_in_active << "/" << m_in_max;
        map["out"] << m_out_active << "/" << m_out_max;
        map["fixed"] = m_fixed_active;
        map["reserved"] = m_reserved;
        map["total"] = m_active;
    }
 
    std::string
    state_string() const
    {
        std::stringstream ss;
        ss << m_out_active << "/" << m_out_max << " out, " << m_in_active << "/" << m_in_max << " in, "
           << connectCount() << " connecting, " << closingCount() << " closing";
        return ss.str();
    }
 
    //--------------------------------------------------------------------------
private:
    // Adjusts counts based on the specified slot, in the direction indicated.
    void
    adjust(Slot const& s, int const n)
    {
        if (s.fixed())
            m_fixed += n;
 
        if (s.reserved())
            m_reserved += n;
 
        switch (s.state())
        {
            case Slot::accept:
                XRPL_ASSERT(s.inbound(), "xrpl::PeerFinder::Counts::adjust : input is inbound");
                m_acceptCount += n;
                break;
 
            case Slot::connect:
            case Slot::connected:
                XRPL_ASSERT(
                    !s.inbound(),
                    "xrpl::PeerFinder::Counts::adjust : input is not "
                    "inbound");
                m_attempts += n;
                break;
 
            case Slot::active:
                if (s.fixed())
                    m_fixed_active += n;
                if (!s.fixed() && !s.reserved())
                {
                    if (s.inbound())
                        m_in_active += n;
                    else
                        m_out_active += n;
                }
                m_active += n;
                break;
 
            case Slot::closing:
                m_closingCount += n;
                break;
 
            // LCOV_EXCL_START
            default:
                UNREACHABLE("xrpl::PeerFinder::Counts::adjust : invalid input state");
                break;
                // LCOV_EXCL_STOP
        };
    }
 
private:
    int m_attempts;
 
    std::size_t m_active;
 
    std::size_t m_in_max;
 
    std::size_t m_in_active;
 
    std::size_t m_out_max;
 
    std::size_t m_out_active;
 
    std::size_t m_fixed;
 
    std::size_t m_fixed_active;
 
    std::size_t m_reserved;
 
    // Number of inbound connections that are
    // not active or gracefully closing.
    int m_acceptCount;
 
    // Number of connections that are gracefully closing.
    int m_closingCount;
};
 
}  // namespace PeerFinder
}  // namespace xrpl