InfoSub.h

#ifndef XRPL_NET_INFOSUB_H_INCLUDED
#define XRPL_NET_INFOSUB_H_INCLUDED
 
#include <xrpld/app/misc/Manifest.h>
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/resource/Consumer.h>
 
namespace ripple {
 
// Operations that clients may wish to perform against the network
// Master operational handler, server sequencer, network tracker
 
class InfoSubRequest : public CountedObject<InfoSubRequest>
{
public:
    using pointer = std::shared_ptr<InfoSubRequest>;
 
    virtual ~InfoSubRequest() = default;
 
    virtual Json::Value
    doClose() = 0;
    virtual Json::Value
    doStatus(Json::Value const&) = 0;
};
 
class InfoSub : public CountedObject<InfoSub>
{
public:
    using pointer = std::shared_ptr<InfoSub>;
 
    // VFALCO TODO Standardize on the names of weak / strong pointer type
    // aliases.
    using wptr = std::weak_ptr<InfoSub>;
 
    using ref = std::shared_ptr<InfoSub> const&;
 
    using Consumer = Resource::Consumer;
 
public:
    class Source
    {
    public:
        virtual ~Source() = default;
 
        // For some reason, these were originally called "rt"
        // for "real time". They actually refer to whether
        // you get transactions as they occur or once their
        // results are confirmed
        virtual void
        subAccount(
            ref ispListener,
            hash_set<AccountID> const& vnaAccountIDs,
            bool realTime) = 0;
 
        // for normal use, removes from InfoSub and server
        virtual void
        unsubAccount(
            ref isplistener,
            hash_set<AccountID> const& vnaAccountIDs,
            bool realTime) = 0;
 
        // for use during InfoSub destruction
        // Removes only from the server
        virtual void
        unsubAccountInternal(
            std::uint64_t uListener,
            hash_set<AccountID> const& vnaAccountIDs,
            bool realTime) = 0;
 
        virtual error_code_i
        subAccountHistory(ref ispListener, AccountID const& account) = 0;
 
        virtual void
        unsubAccountHistory(
            ref ispListener,
            AccountID const& account,
            bool historyOnly) = 0;
 
        virtual void
        unsubAccountHistoryInternal(
            std::uint64_t uListener,
            AccountID const& account,
            bool historyOnly) = 0;
 
        // VFALCO TODO Document the bool return value
        virtual bool
        subLedger(ref ispListener, Json::Value& jvResult) = 0;
        virtual bool
        unsubLedger(std::uint64_t uListener) = 0;
 
        virtual bool
        subBookChanges(ref ispListener) = 0;
        virtual bool
        unsubBookChanges(std::uint64_t uListener) = 0;
 
        virtual bool
        subManifests(ref ispListener) = 0;
        virtual bool
        unsubManifests(std::uint64_t uListener) = 0;
        virtual void
        pubManifest(Manifest const&) = 0;
 
        virtual bool
        subServer(ref ispListener, Json::Value& jvResult, bool admin) = 0;
        virtual bool
        unsubServer(std::uint64_t uListener) = 0;
 
        virtual bool
        subBook(ref ispListener, Book const&) = 0;
        virtual bool
        unsubBook(std::uint64_t uListener, Book const&) = 0;
 
        virtual bool
        subTransactions(ref ispListener) = 0;
        virtual bool
        unsubTransactions(std::uint64_t uListener) = 0;
 
        virtual bool
        subRTTransactions(ref ispListener) = 0;
        virtual bool
        unsubRTTransactions(std::uint64_t uListener) = 0;
 
        virtual bool
        subValidations(ref ispListener) = 0;
        virtual bool
        unsubValidations(std::uint64_t uListener) = 0;
 
        virtual bool
        subPeerStatus(ref ispListener) = 0;
        virtual bool
        unsubPeerStatus(std::uint64_t uListener) = 0;
        virtual void
        pubPeerStatus(std::function<Json::Value(void)> const&) = 0;
 
        virtual bool
        subConsensus(ref ispListener) = 0;
        virtual bool
        unsubConsensus(std::uint64_t uListener) = 0;
 
        // VFALCO TODO Remove
        //             This was added for one particular partner, it
        //             "pushes" subscription data to a particular URL.
        //
        virtual pointer
        findRpcSub(std::string const& strUrl) = 0;
        virtual pointer
        addRpcSub(std::string const& strUrl, ref rspEntry) = 0;
        virtual bool
        tryRemoveRpcSub(std::string const& strUrl) = 0;
    };
 
public:
    InfoSub(Source& source);
    InfoSub(Source& source, Consumer consumer);
 
    virtual ~InfoSub();
 
    Consumer&
    getConsumer();
 
    virtual void
    send(Json::Value const& jvObj, bool broadcast) = 0;
 
    std::uint64_t
    getSeq();
 
    void
    onSendEmpty();
 
    void
    insertSubAccountInfo(AccountID const& account, bool rt);
 
    void
    deleteSubAccountInfo(AccountID const& account, bool rt);
 
    // return false if already subscribed to this account
    bool
    insertSubAccountHistory(AccountID const& account);
 
    void
    deleteSubAccountHistory(AccountID const& account);
 
    void
    clearRequest();
 
    void
    setRequest(std::shared_ptr<InfoSubRequest> const& req);
 
    std::shared_ptr<InfoSubRequest> const&
    getRequest();
 
    void
    setApiVersion(unsigned int apiVersion);
 
    unsigned int
    getApiVersion() const noexcept;
 
protected:
    std::mutex mLock;
 
private:
    Consumer m_consumer;
    Source& m_source;
    hash_set<AccountID> realTimeSubscriptions_;
    hash_set<AccountID> normalSubscriptions_;
    std::shared_ptr<InfoSubRequest> request_;
    std::uint64_t mSeq;
    hash_set<AccountID> accountHistorySubscriptions_;
    unsigned int apiVersion_ = 0;
 
    static int
    assign_id()
    {
        static std::atomic<std::uint64_t> id(0);
        return ++id;
    }
};
 
}  // namespace ripple
 
#endif