PluginManager.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/cache/CacheConfiguration.h"
#include "catapult/cache/CatapultCacheBuilder.h"
#include "catapult/config/InflationConfiguration.h"
#include "catapult/ionet/PacketHandlers.h"
#include "catapult/model/BlockChainConfiguration.h"
#include "catapult/model/NotificationPublisher.h"
#include "catapult/model/TransactionPlugin.h"
#include "catapult/observers/DemuxObserverBuilder.h"
#include "catapult/observers/ObserverTypes.h"
#include "catapult/utils/DiagnosticCounter.h"
#include "catapult/validators/DemuxValidatorBuilder.h"
#include "catapult/validators/ValidatorTypes.h"
#include "catapult/plugins.h"
 
namespace catapult { namespace plugins {
 
    struct StorageConfiguration {
        bool PreferCacheDatabase = false;
 
        std::string CacheDatabaseDirectory;
 
        utils::FileSize MaxCacheDatabaseWriteBatchSize;
    };
 
    class PluginManager {
    private:
        using HandlerHook = consumer<ionet::ServerPacketHandlers&, const cache::CatapultCache&>;
        using CounterHook = consumer<std::vector<utils::DiagnosticCounter>&, const cache::CatapultCache&>;
        using StatelessValidatorHook = consumer<validators::stateless::DemuxValidatorBuilder&>;
        using StatefulValidatorHook = consumer<validators::stateful::DemuxValidatorBuilder&>;
        using ObserverHook = consumer<observers::DemuxObserverBuilder&>;
 
        using StatelessValidatorPointer = std::unique_ptr<const validators::stateless::AggregateNotificationValidator>;
        using StatefulValidatorPointer = std::unique_ptr<const validators::stateful::AggregateNotificationValidator>;
        using ObserverPointer = observers::AggregateNotificationObserverPointerT<model::Notification>;
 
        template<typename TUnresolved, typename TResolved>
        using Resolver = predicate<const cache::ReadOnlyCatapultCache&, const TUnresolved&, TResolved&>;
        using MosaicResolver = Resolver<UnresolvedMosaicId, MosaicId>;
        using AddressResolver = Resolver<UnresolvedAddress, Address>;
 
        template<typename TUnresolved, typename TResolved>
        using AggregateResolver = std::function<TResolved (const cache::ReadOnlyCatapultCache&, const TUnresolved&)>;
        using AggregateMosaicResolver = AggregateResolver<UnresolvedMosaicId, MosaicId>;
        using AggregateAddressResolver = AggregateResolver<UnresolvedAddress, Address>;
 
        using PublisherPointer = std::unique_ptr<model::NotificationPublisher>;
 
    public:
        PluginManager(
                const model::BlockChainConfiguration& config,
                const StorageConfiguration& storageConfig,
                const config::InflationConfiguration& inflationConfig);
 
    public:
        // region config
 
        const model::BlockChainConfiguration& config() const;
 
        const StorageConfiguration& storageConfig() const;
 
        cache::CacheConfiguration cacheConfig(const std::string& name) const;
 
        const config::InflationConfiguration& inflationConfig() const;
 
        // endregion
 
        // region transactions
 
        void addTransactionSupport(std::unique_ptr<model::TransactionPlugin>&& pTransactionPlugin);
 
        const model::TransactionRegistry& transactionRegistry() const;
 
        // endregion
 
        // region cache
 
        template<typename TStorageTraits, typename TCache>
        void addCacheSupport(std::unique_ptr<TCache>&& pSubCache) {
            m_cacheBuilder.add<TStorageTraits>(std::move(pSubCache));
        }
 
        void addCacheSupport(std::unique_ptr<cache::SubCachePlugin>&& pSubCachePlugin);
 
        cache::CatapultCache createCache();
 
        // endregion
 
        // region handlers
 
        void addHandlerHook(const HandlerHook& hook);
 
        void addHandlers(ionet::ServerPacketHandlers& handlers, const cache::CatapultCache& cache) const;
 
        // endregion
 
        // region diagnostics
 
        void addDiagnosticHandlerHook(const HandlerHook& hook);
 
        void addDiagnosticCounterHook(const CounterHook& hook);
 
        void addDiagnosticHandlers(ionet::ServerPacketHandlers& handlers, const cache::CatapultCache& cache) const;
 
        void addDiagnosticCounters(std::vector<utils::DiagnosticCounter>& counters, const cache::CatapultCache& cache) const;
 
        // endregion
 
        // region validators
 
        void addStatelessValidatorHook(const StatelessValidatorHook& hook);
 
        void addStatefulValidatorHook(const StatefulValidatorHook& hook);
 
        StatelessValidatorPointer createStatelessValidator(const validators::ValidationResultPredicate& isSuppressedFailure) const;
 
        StatelessValidatorPointer createStatelessValidator() const;
 
        StatefulValidatorPointer createStatefulValidator(const validators::ValidationResultPredicate& isSuppressedFailure) const;
 
        StatefulValidatorPointer createStatefulValidator() const;
 
        // endregion
 
        // region observers
 
        void addObserverHook(const ObserverHook& hook);
 
        void addTransientObserverHook(const ObserverHook& hook);
 
        ObserverPointer createObserver() const;
 
        ObserverPointer createPermanentObserver() const;
 
        // endregion
 
        // region resolvers
 
        void addMosaicResolver(const MosaicResolver& resolver);
 
        void addAddressResolver(const AddressResolver& resolver);
 
        model::ResolverContext createResolverContext(const cache::ReadOnlyCatapultCache& cache) const;
 
        // endregion
 
        // region publisher
 
        PublisherPointer createNotificationPublisher(model::PublicationMode mode = model::PublicationMode::All) const;
 
        // endregion
 
    private:
        model::BlockChainConfiguration m_config;
        StorageConfiguration m_storageConfig;
        config::InflationConfiguration m_inflationConfig;
        model::TransactionRegistry m_transactionRegistry;
        cache::CatapultCacheBuilder m_cacheBuilder;
 
        std::vector<HandlerHook> m_nonDiagnosticHandlerHooks;
        std::vector<HandlerHook> m_diagnosticHandlerHooks;
        std::vector<CounterHook> m_diagnosticCounterHooks;
        std::vector<StatelessValidatorHook> m_statelessValidatorHooks;
        std::vector<StatefulValidatorHook> m_statefulValidatorHooks;
        std::vector<ObserverHook> m_observerHooks;
        std::vector<ObserverHook> m_transientObserverHooks;
 
        std::vector<MosaicResolver> m_mosaicResolvers;
        std::vector<AddressResolver> m_addressResolvers;
    };
}}
 
extern "C" PLUGIN_API
void RegisterSubsystem(catapult::plugins::PluginManager& manager);