Bootcache.cpp

#include <xrpld/peerfinder/detail/Bootcache.h>
#include <xrpld/peerfinder/detail/Tuning.h>
#include <xrpld/peerfinder/detail/iosformat.h>
 
#include <xrpl/basics/Log.h>
 
#include <algorithm>
 
namespace xrpl {
namespace PeerFinder {
 
Bootcache::Bootcache(Store& store, clock_type& clock, beast::Journal journal)
    : m_store(store), m_clock(clock), m_journal(journal), m_whenUpdate(m_clock.now())
 
{
}
 
Bootcache::~Bootcache()
{
    update();
}
 
bool
Bootcache::empty() const
{
    return m_map.empty();
}
 
Bootcache::map_type::size_type
Bootcache::size() const
{
    return m_map.size();
}
 
Bootcache::const_iterator
Bootcache::begin() const
{
    return const_iterator(m_map.right.begin());
}
 
Bootcache::const_iterator
Bootcache::cbegin() const
{
    return const_iterator(m_map.right.begin());
}
 
Bootcache::const_iterator
Bootcache::end() const
{
    return const_iterator(m_map.right.end());
}
 
Bootcache::const_iterator
Bootcache::cend() const
{
    return const_iterator(m_map.right.end());
}
 
void
Bootcache::clear()
{
    m_map.clear();
    m_needsUpdate = true;
}
 
//--------------------------------------------------------------------------
 
void
Bootcache::load()
{
    clear();
    auto const n(m_store.load([this](beast::IP::Endpoint const& endpoint, int valence) {
        auto const result(this->m_map.insert(value_type(endpoint, valence)));
        if (!result.second)
        {
            JLOG(this->m_journal.error()) << beast::leftw(18) << "Bootcache discard " << endpoint;
        }
    }));
 
    if (n > 0)
    {
        JLOG(m_journal.info()) << beast::leftw(18) << "Bootcache loaded " << n
                               << ((n > 1) ? " addresses" : " address");
        prune();
    }
}
 
bool
Bootcache::insert(beast::IP::Endpoint const& endpoint)
{
    auto const result(m_map.insert(value_type(endpoint, 0)));
    if (result.second)
    {
        JLOG(m_journal.trace()) << beast::leftw(18) << "Bootcache insert " << endpoint;
        prune();
        flagForUpdate();
    }
    return result.second;
}
 
bool
Bootcache::insertStatic(beast::IP::Endpoint const& endpoint)
{
    auto result(m_map.insert(value_type(endpoint, staticValence)));
 
    if (!result.second && (result.first->right.valence() < staticValence))
    {
        // An existing entry has too low a valence, replace it
        m_map.erase(result.first);
        result = m_map.insert(value_type(endpoint, staticValence));
    }
 
    if (result.second)
    {
        JLOG(m_journal.trace()) << beast::leftw(18) << "Bootcache insert " << endpoint;
        prune();
        flagForUpdate();
    }
    return result.second;
}
 
void
Bootcache::on_success(beast::IP::Endpoint const& endpoint)
{
    auto result(m_map.insert(value_type(endpoint, 1)));
    if (result.second)
    {
        prune();
    }
    else
    {
        Entry entry(result.first->right);
        entry.valence() = std::max(entry.valence(), 0);
        ++entry.valence();
        m_map.erase(result.first);
        result = m_map.insert(value_type(endpoint, entry));
        XRPL_ASSERT(result.second, "ripple:PeerFinder::Bootcache::on_success : endpoint inserted");
    }
    Entry const& entry(result.first->right);
    JLOG(m_journal.info()) << beast::leftw(18) << "Bootcache connect " << endpoint << " with "
                           << entry.valence()
                           << ((entry.valence() > 1) ? " successes" : " success");
    flagForUpdate();
}
 
void
Bootcache::on_failure(beast::IP::Endpoint const& endpoint)
{
    auto result(m_map.insert(value_type(endpoint, -1)));
    if (result.second)
    {
        prune();
    }
    else
    {
        Entry entry(result.first->right);
        entry.valence() = std::min(entry.valence(), 0);
        --entry.valence();
        m_map.erase(result.first);
        result = m_map.insert(value_type(endpoint, entry));
        XRPL_ASSERT(result.second, "ripple:PeerFinder::Bootcache::on_failure : endpoint inserted");
    }
    Entry const& entry(result.first->right);
    auto const n(std::abs(entry.valence()));
    JLOG(m_journal.debug()) << beast::leftw(18) << "Bootcache failed " << endpoint << " with " << n
                            << ((n > 1) ? " attempts" : " attempt");
    flagForUpdate();
}
 
void
Bootcache::periodicActivity()
{
    checkUpdate();
}
 
//--------------------------------------------------------------------------
 
void
Bootcache::onWrite(beast::PropertyStream::Map& map)
{
    beast::PropertyStream::Set entries("entries", map);
    for (auto iter = m_map.right.begin(); iter != m_map.right.end(); ++iter)
    {
        beast::PropertyStream::Map entry(entries);
        entry["endpoint"] = iter->get_left().to_string();
        entry["valence"] = std::int32_t(iter->get_right().valence());
    }
}
 
// Checks the cache size and prunes if its over the limit.
void
Bootcache::prune()
{
    if (size() <= Tuning::bootcacheSize)
        return;
 
    // Calculate the amount to remove
    auto count((size() * Tuning::bootcachePrunePercent) / 100);
    decltype(count) pruned(0);
 
    // Work backwards because bimap doesn't handle
    // erasing using a reverse iterator very well.
    //
    for (auto iter(m_map.right.end()); count-- > 0 && iter != m_map.right.begin(); ++pruned)
    {
        --iter;
        beast::IP::Endpoint const& endpoint(iter->get_left());
        Entry const& entry(iter->get_right());
        JLOG(m_journal.trace()) << beast::leftw(18) << "Bootcache pruned" << endpoint
                                << " at valence " << entry.valence();
        iter = m_map.right.erase(iter);
    }
 
    JLOG(m_journal.debug()) << beast::leftw(18) << "Bootcache pruned " << pruned
                            << " entries total";
}
 
// Updates the Store with the current set of entries if needed.
void
Bootcache::update()
{
    if (!m_needsUpdate)
        return;
    std::vector<Store::Entry> list;
    list.reserve(m_map.size());
    for (auto const& e : m_map)
    {
        Store::Entry se;
        se.endpoint = e.get_left();
        se.valence = e.get_right().valence();
        list.push_back(se);
    }
    m_store.save(list);
    // Reset the flag and cooldown timer
    m_needsUpdate = false;
    m_whenUpdate = m_clock.now() + Tuning::bootcacheCooldownTime;
}
 
// Checks the clock and calls update if we are off the cooldown.
void
Bootcache::checkUpdate()
{
    if (m_needsUpdate && m_whenUpdate < m_clock.now())
        update();
}
 
// Called when changes to an entry will affect the Store.
void
Bootcache::flagForUpdate()
{
    m_needsUpdate = true;
    checkUpdate();
}
 
}  // namespace PeerFinder
}  // namespace xrpl