invrequest.h

Go to the documentation of this file.

// Copyright (c) 2020 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_INVREQUEST_H
#define BITCOIN_INVREQUEST_H
 
#include <net.h> // For NodeId
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <vector>
 
// Avoid littering this header file with implementation details.
class InvRequestTrackerImplInterface {
    template <class InvId> friend class InvRequestTracker;
 
    // The base class is responsible for building the child implementation.
    // This is a hack that allows for hiding the concrete implementation details
    // from the callsite.
    static std::unique_ptr<InvRequestTrackerImplInterface>
    BuildImpl(bool deterministic);
 
public:
    using ClearExpiredFun = const std::function<void()> &;
    using EmplaceExpiredFun =
        const std::function<void(const NodeId &, const uint256 &)> &;
 
    virtual ~InvRequestTrackerImplInterface() = default;
 
    virtual void ReceivedInv(NodeId peer, const uint256 &invid, bool preferred,
                             std::chrono::microseconds reqtime) = 0;
    virtual void DisconnectedPeer(NodeId peer) = 0;
    virtual void ForgetInvId(const uint256 &invid) = 0;
    virtual std::vector<uint256>
    GetRequestable(NodeId peer, std::chrono::microseconds now,
                   ClearExpiredFun clearExpired,
                   EmplaceExpiredFun emplaceExpired) = 0;
    virtual void RequestedData(NodeId peer, const uint256 &invid,
                               std::chrono::microseconds expiry) = 0;
    virtual void ReceivedResponse(NodeId peer, const uint256 &invid) = 0;
    virtual size_t CountInFlight(NodeId peer) const = 0;
    virtual size_t CountCandidates(NodeId peer) const = 0;
    virtual size_t Count(NodeId peer) const = 0;
    virtual size_t Size() const = 0;
    virtual uint64_t ComputePriority(const uint256 &invid, NodeId peer,
                                     bool preferred) const = 0;
    virtual void SanityCheck() const = 0;
    virtual void
    PostGetRequestableSanityCheck(std::chrono::microseconds now) const = 0;
};
 
template <class InvId> class InvRequestTracker {
    /*
     * Only uint256-based InvId types are supported for now.
     * FIXME: use a template constraint when C++20 is available.
     */
    static_assert(std::is_base_of<uint256, InvId>::value,
                  "InvRequestTracker inv id type should be uint256 or derived");
 
    const std::unique_ptr<InvRequestTrackerImplInterface> m_impl;
 
public:
    explicit InvRequestTracker(bool deterministic = false)
        : m_impl{InvRequestTrackerImplInterface::BuildImpl(deterministic)} {}
    ~InvRequestTracker() = default;
 
    // Conceptually, the data structure consists of a collection of
    // "announcements", one for each peer/invid combination:
    //
    // - CANDIDATE announcements represent inventories that were announced by a
    //   peer, and that become available for download after their reqtime has
    //   passed.
    //
    // - REQUESTED announcements represent inventories that have been
    //   requested, and which we're awaiting a response for from that peer.
    //   Their expiry value determines when the request times out.
    //
    // - COMPLETED announcements represent inventories that have been requested
    //   from a peer, and a NOTFOUND or an inventory was received in response
    //   (valid or not), or they timed out. They're only kept around to prevent
    //   requesting them again. If only COMPLETED announcements for a given
    //   invid remain (so no CANDIDATE or REQUESTED ones), all of them are
    //   deleted (this is an invariant, and maintained by all operations below).
    //
    // The operations below manipulate the data structure.
 
    void ReceivedInv(NodeId peer, const InvId &invid, bool preferred,
                     std::chrono::microseconds reqtime) {
        m_impl->ReceivedInv(peer, invid, preferred, reqtime);
    }
 
    void DisconnectedPeer(NodeId peer) { m_impl->DisconnectedPeer(peer); }
 
    void ForgetInvId(const InvId &invid) { m_impl->ForgetInvId(invid); }
 
    std::vector<InvId>
    GetRequestable(NodeId peer, std::chrono::microseconds now,
                   std::vector<std::pair<NodeId, InvId>> *expired) {
        InvRequestTrackerImplInterface::ClearExpiredFun clearExpired =
            [expired]() {
                if (expired) {
                    expired->clear();
                }
            };
        InvRequestTrackerImplInterface::EmplaceExpiredFun emplaceExpired =
            [expired](const NodeId &nodeid, const uint256 &invid) {
                if (expired) {
                    expired->emplace_back(nodeid, InvId(invid));
                }
            };
        std::vector<uint256> hashes =
            m_impl->GetRequestable(peer, now, clearExpired, emplaceExpired);
        return std::vector<InvId>(hashes.begin(), hashes.end());
    }
 
    void RequestedData(NodeId peer, const InvId &invid,
                       std::chrono::microseconds expiry) {
        m_impl->RequestedData(peer, invid, expiry);
    }
 
    void ReceivedResponse(NodeId peer, const InvId &invid) {
        m_impl->ReceivedResponse(peer, invid);
    }
 
    // The operations below inspect the data structure.
 
    size_t CountInFlight(NodeId peer) const {
        return m_impl->CountInFlight(peer);
    }
 
    size_t CountCandidates(NodeId peer) const {
        return m_impl->CountCandidates(peer);
    }
 
    size_t Count(NodeId peer) const { return m_impl->Count(peer); }
 
    size_t Size() const { return m_impl->Size(); }
 
    uint64_t ComputePriority(const InvId &invid, NodeId peer,
                             bool preferred) const {
        return m_impl->ComputePriority(invid, peer, preferred);
    }
 
    void SanityCheck() const { m_impl->SanityCheck(); }
 
    void PostGetRequestableSanityCheck(std::chrono::microseconds now) const {
        m_impl->PostGetRequestableSanityCheck(now);
    }
};
 
#endif // BITCOIN_INVREQUEST_H