ServerHooks.h

Go to the documentation of this file.

 
#pragma once
#include "BasicServerHooks.h"
#include "TransactionEvent.h"
#include "catapult/cache_tx/MemoryUtCache.h"
#include "catapult/chain/ChainFunctions.h"
#include "catapult/chain/ChainSynchronizer.h"
#include "catapult/consumers/BlockConsumers.h"
#include "catapult/consumers/InputUtils.h"
#include "catapult/disruptor/DisruptorElement.h"
#include "catapult/handlers/HandlerTypes.h"
#include "catapult/ionet/PacketPayload.h"
 
namespace catapult { namespace extensions {
 
    // region function aliases
 
    using NewBlockSink = consumers::NewBlockSink;
 
    using SharedNewTransactionsSink = consumer<const consumers::TransactionInfos&>;
 
    using PacketPayloadSink = consumer<const ionet::PacketPayload&>;
 
    using TransactionsChangeHandler = consumers::BlockChainSyncHandlers::TransactionsChangeFunc;
 
    using BlockRangeConsumerFunc = handlers::BlockRangeHandler;
 
    using BlockRangeConsumerFactoryFunc = std::function<BlockRangeConsumerFunc (disruptor::InputSource)>;
 
    using CompletionAwareBlockRangeConsumerFactoryFunc =
            std::function<chain::CompletionAwareBlockRangeConsumerFunc (disruptor::InputSource)>;
 
    using TransactionRangeConsumerFunc = handlers::TransactionRangeHandler;
 
    using TransactionRangeConsumerFactoryFunc = std::function<TransactionRangeConsumerFunc (disruptor::InputSource)>;
 
    using RemoteChainHeightsRetriever = std::function<thread::future<std::vector<Height>> (size_t)>;
 
    using ChainSyncedPredicate = predicate<>;
 
    using KnownHashPredicate = chain::KnownHashPredicate;
 
    // endregion
 
    class ServerHooks {
    public:
        void addNewBlockSink(const NewBlockSink& sink) {
            m_newBlockSinks.push_back(sink);
        }
 
        void addNewTransactionsSink(const SharedNewTransactionsSink& sink) {
            m_newTransactionsSinks.push_back(sink);
        }
 
        void addPacketPayloadSink(const PacketPayloadSink& sink) {
            m_packetPayloadSinks.push_back(sink);
        }
 
        void addTransactionsChangeHandler(const TransactionsChangeHandler& handler) {
            m_transactionsChangeHandlers.push_back(handler);
        }
 
        void addTransactionEventHandler(const TransactionEventHandler& handler) {
            m_transactionEventHandlers.push_back(handler);
        }
 
        void setBlockRangeConsumerFactory(const BlockRangeConsumerFactoryFunc& factory) {
            SetOnce(m_blockRangeConsumerFactory, factory);
        }
 
        void setCompletionAwareBlockRangeConsumerFactory(const CompletionAwareBlockRangeConsumerFactoryFunc& factory) {
            SetOnce(m_completionAwareBlockRangeConsumerFactory, factory);
        }
 
        void setTransactionRangeConsumerFactory(const TransactionRangeConsumerFactoryFunc& factory) {
            SetOnce(m_transactionRangeConsumerFactory, factory);
        }
 
        void setRemoteChainHeightsRetriever(const RemoteChainHeightsRetriever& retriever) {
            SetOnce(m_remoteChainHeightsRetriever, retriever);
        }
 
        void setChainSyncedPredicate(const ChainSyncedPredicate& predicate) {
            SetOnce(m_chainSyncedPredicate, predicate);
        }
 
        void addKnownHashPredicate(const KnownHashPredicate& predicate) {
            m_knownHashPredicates.push_back(predicate);
        }
 
    public:
        auto newBlockSink() const {
            return AggregateConsumers(m_newBlockSinks);
        }
 
        auto newTransactionsSink() const {
            return AggregateConsumers(m_newTransactionsSinks);
        }
 
        auto packetPayloadSink() const {
            return AggregateConsumers(m_packetPayloadSinks);
        }
 
        auto transactionsChangeHandler() const {
            return AggregateConsumers(m_transactionsChangeHandlers);
        }
 
        auto transactionEventHandler() const {
            return AggregateConsumers(m_transactionEventHandlers);
        }
 
        const auto& blockRangeConsumerFactory() const {
            return Require(m_blockRangeConsumerFactory);
        }
 
        const auto& completionAwareBlockRangeConsumerFactory() const {
            return Require(m_completionAwareBlockRangeConsumerFactory);
        }
 
        const auto& transactionRangeConsumerFactory() const {
            return Require(m_transactionRangeConsumerFactory);
        }
 
        const auto& remoteChainHeightsRetriever() const {
            return Require(m_remoteChainHeightsRetriever);
        }
 
        auto chainSyncedPredicate() const {
            return m_chainSyncedPredicate ? m_chainSyncedPredicate : []() { return true; };
        }
 
        KnownHashPredicate knownHashPredicate(const cache::MemoryUtCache& utCache) const {
            return [&utCache, knownHashPredicates = m_knownHashPredicates](auto timestamp, const auto& hash) {
                if (utCache.view().contains(hash))
                    return true;
 
                for (const auto& knownHashPredicate : knownHashPredicates) {
                    if (knownHashPredicate(timestamp, hash))
                        return true;
                }
 
                return false;
            };
        }
 
    private:
        std::vector<NewBlockSink> m_newBlockSinks;
        std::vector<SharedNewTransactionsSink> m_newTransactionsSinks;
        std::vector<PacketPayloadSink> m_packetPayloadSinks;
        std::vector<TransactionsChangeHandler> m_transactionsChangeHandlers;
        std::vector<TransactionEventHandler> m_transactionEventHandlers;
 
        BlockRangeConsumerFactoryFunc m_blockRangeConsumerFactory;
        CompletionAwareBlockRangeConsumerFactoryFunc m_completionAwareBlockRangeConsumerFactory;
        TransactionRangeConsumerFactoryFunc m_transactionRangeConsumerFactory;
 
        RemoteChainHeightsRetriever m_remoteChainHeightsRetriever;
        ChainSyncedPredicate m_chainSyncedPredicate;
        std::vector<KnownHashPredicate> m_knownHashPredicates;
    };
}}