Struct mithril_aggregator::dependency_injection::DependenciesBuilder

pub struct DependenciesBuilder {

    pub configuration: Configuration,
    pub root_logger: Logger,
    pub sqlite_connection: Option<Arc<SqliteConnection>>,
    pub sqlite_connection_event_store: Option<Arc<SqliteConnection>>,
    pub sqlite_connection_cardano_transaction_pool: Option<Arc<SqliteConnectionPool>>,
    pub stake_store: Option<Arc<StakePoolStore>>,
    pub snapshot_uploader: Option<Arc<dyn SnapshotUploader>>,
    pub multi_signer: Option<Arc<dyn MultiSigner>>,
    pub certificate_pending_store: Option<Arc<CertificatePendingStore>>,
    pub certificate_repository: Option<Arc<CertificateRepository>>,
    pub open_message_repository: Option<Arc<OpenMessageRepository>>,
    pub verification_key_store: Option<Arc<dyn VerificationKeyStorer>>,
    pub epoch_settings_store: Option<Arc<EpochSettingsStore>>,
    pub cardano_cli_runner: Option<Box<CardanoCliRunner>>,
    pub chain_observer: Option<Arc<dyn ChainObserver>>,
    pub chain_block_reader: Option<Arc<Mutex<dyn ChainBlockReader>>>,
    pub transaction_repository: Option<Arc<CardanoTransactionRepository>>,
    pub block_scanner: Option<Arc<dyn BlockScanner>>,
    pub immutable_digester: Option<Arc<dyn ImmutableDigester>>,
    pub immutable_file_observer: Option<Arc<dyn ImmutableFileObserver>>,
    pub immutable_cache_provider: Option<Arc<dyn ImmutableFileDigestCacheProvider>>,
    pub digester: Option<Arc<dyn ImmutableDigester>>,
    pub snapshotter: Option<Arc<dyn Snapshotter>>,
    pub certificate_verifier: Option<Arc<dyn CertificateVerifier>>,
    pub genesis_verifier: Option<Arc<ProtocolGenesisVerifier>>,
    pub mithril_registerer: Option<Arc<MithrilSignerRegisterer>>,
    pub era_checker: Option<Arc<EraChecker>>,
    pub era_reader_adapter: Option<Arc<dyn EraReaderAdapter>>,
    pub era_reader: Option<Arc<EraReader>>,
    pub event_transmitter: Option<Arc<TransmitterService<EventMessage>>>,
    pub event_transmitter_channel: (Option<UnboundedReceiver<EventMessage>>, Option<UnboundedSender<EventMessage>>),
    pub api_version_provider: Option<Arc<APIVersionProvider>>,
    pub stake_distribution_service: Option<Arc<dyn StakeDistributionService>>,
    pub ticker_service: Option<Arc<dyn TickerService>>,
    pub signer_store: Option<Arc<SignerStore>>,
    pub signable_seed_builder: Option<Arc<dyn SignableSeedBuilder>>,
    pub signable_builder_service: Option<Arc<dyn SignableBuilderService>>,
    pub signed_entity_service: Option<Arc<dyn SignedEntityService>>,
    pub certifier_service: Option<Arc<dyn CertifierService>>,
    pub epoch_service: Option<EpochServiceWrapper>,
    pub signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>,
    pub message_service: Option<Arc<dyn MessageService>>,
    pub prover_service: Option<Arc<dyn ProverService>>,
    pub signed_entity_type_lock: Option<Arc<SignedEntityTypeLock>>,
    pub transactions_importer: Option<Arc<dyn TransactionsImporter>>,
    pub upkeep_service: Option<Arc<dyn UpkeepService>>,
    pub single_signer_authenticator: Option<Arc<SingleSignatureAuthenticator>>,
    pub metrics_service: Option<Arc<MetricsService>>,
}

Dependencies container builder

This is meant to create SHARED DEPENDENCIES, ie: dependencies instances that must be shared amongst several Tokio tasks. For example, database repositories are NOT shared dependencies and therefor can be created ad hoc whereas the database connection is a shared dependency.

Each shared dependency must implement a build and a get function. The build function creates the dependency, the get function creates the dependency at first call then return a clone of the Arc containing the dependency for all further calls.

Fields

configuration: Configuration

Configuration parameters

root_logger: Logger

Application root logger

sqlite_connection: Option<Arc<SqliteConnection>>

SQLite database connection

sqlite_connection_event_store: Option<Arc<SqliteConnection>>

Event store SQLite database connection

sqlite_connection_cardano_transaction_pool: Option<Arc<SqliteConnectionPool>>

Cardano transactions SQLite database connection pool

stake_store: Option<Arc<StakePoolStore>>

Stake Store used by the StakeDistributionService It shall be a private dependency.

snapshot_uploader: Option<Arc<dyn SnapshotUploader>>

Snapshot uploader service.

multi_signer: Option<Arc<dyn MultiSigner>>

Multisigner service.

certificate_pending_store: Option<Arc<CertificatePendingStore>>

Certificate pending store.

certificate_repository: Option<Arc<CertificateRepository>>

Certificate repository.

open_message_repository: Option<Arc<OpenMessageRepository>>

Open message repository.

verification_key_store: Option<Arc<dyn VerificationKeyStorer>>

Verification key store.

epoch_settings_store: Option<Arc<EpochSettingsStore>>

Epoch settings store.

cardano_cli_runner: Option<Box<CardanoCliRunner>>

Cardano CLI Runner for the ChainObserver

chain_observer: Option<Arc<dyn ChainObserver>>

Chain observer service.

chain_block_reader: Option<Arc<Mutex<dyn ChainBlockReader>>>

Chain block reader

transaction_repository: Option<Arc<CardanoTransactionRepository>>

Cardano transactions repository.

block_scanner: Option<Arc<dyn BlockScanner>>

Cardano block scanner.

immutable_digester: Option<Arc<dyn ImmutableDigester>>

Immutable file digester service.

immutable_file_observer: Option<Arc<dyn ImmutableFileObserver>>

Immutable file observer service.

immutable_cache_provider: Option<Arc<dyn ImmutableFileDigestCacheProvider>>

Immutable cache provider service.

digester: Option<Arc<dyn ImmutableDigester>>

Digester service.

snapshotter: Option<Arc<dyn Snapshotter>>

Snapshotter service.

certificate_verifier: Option<Arc<dyn CertificateVerifier>>

Certificate verifier service.

genesis_verifier: Option<Arc<ProtocolGenesisVerifier>>

Genesis signature verifier service.

mithril_registerer: Option<Arc<MithrilSignerRegisterer>>

Signer registerer service

era_checker: Option<Arc<EraChecker>>

Era checker service

era_reader_adapter: Option<Arc<dyn EraReaderAdapter>>

Adapter for EraReader

era_reader: Option<Arc<EraReader>>

Era reader service

event_transmitter: Option<Arc<TransmitterService<EventMessage>>>

Event Transmitter Service

event_transmitter_channel: (Option<UnboundedReceiver<EventMessage>>, Option<UnboundedSender<EventMessage>>)

Event transmitter Channel Sender endpoint

api_version_provider: Option<Arc<APIVersionProvider>>

API Version provider

stake_distribution_service: Option<Arc<dyn StakeDistributionService>>

Stake Distribution Service

ticker_service: Option<Arc<dyn TickerService>>

Ticker Service

signer_store: Option<Arc<SignerStore>>

Signer Store

signable_seed_builder: Option<Arc<dyn SignableSeedBuilder>>

Signable Seed Builder

signable_builder_service: Option<Arc<dyn SignableBuilderService>>

Signable Builder Service

signed_entity_service: Option<Arc<dyn SignedEntityService>>

Signed Entity Service

certifier_service: Option<Arc<dyn CertifierService>>

Certifier service

epoch_service: Option<EpochServiceWrapper>

Epoch service.

signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>

Signed Entity storer

message_service: Option<Arc<dyn MessageService>>

HTTP Message service

prover_service: Option<Arc<dyn ProverService>>

Prover service

signed_entity_type_lock: Option<Arc<SignedEntityTypeLock>>

Signed Entity Type Lock

transactions_importer: Option<Arc<dyn TransactionsImporter>>

Transactions Importer

upkeep_service: Option<Arc<dyn UpkeepService>>

Upkeep service

single_signer_authenticator: Option<Arc<SingleSignatureAuthenticator>>

Single signer authenticator

metrics_service: Option<Arc<MetricsService>>

Metrics service

Implementations

impl DependenciesBuilder

pub fn new(root_logger: Logger, configuration: Configuration) -> Self

Create a new clean dependency builder

pub async fn get_sqlite_connection(&mut self) -> Result<Arc<SqliteConnection>>

Get SQLite connection

pub async fn get_event_store_sqlite_connection( &mut self, ) -> Result<Arc<SqliteConnection>>

Get EventStore SQLite connection

pub async fn get_sqlite_connection_cardano_transaction_pool( &mut self, ) -> Result<Arc<SqliteConnectionPool>>

Get SQLite connection pool for the cardano transactions store

pub async fn get_stake_store(&mut self) -> Result<Arc<StakePoolStore>>

Return a StakePoolStore

pub async fn get_snapshot_uploader( &mut self, ) -> Result<Arc<dyn SnapshotUploader>>

Get a SnapshotUploader

pub async fn get_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>>

Get a configured multi signer

pub async fn get_certificate_pending_store( &mut self, ) -> Result<Arc<CertificatePendingStore>>

Get a configured CertificatePendingStore.

pub async fn get_certificate_repository( &mut self, ) -> Result<Arc<CertificateRepository>>

Get a configured CertificateRepository.

pub async fn get_open_message_repository( &mut self, ) -> Result<Arc<OpenMessageRepository>>

Get a configured OpenMessageRepository.

pub async fn get_verification_key_store( &mut self, ) -> Result<Arc<dyn VerificationKeyStorer>>

Get a configured VerificationKeyStorer.

pub async fn get_epoch_settings_store( &mut self, ) -> Result<Arc<EpochSettingsStore>>

Get a configured EpochSettingsStorer.

pub async fn get_chain_observer(&mut self) -> Result<Arc<dyn ChainObserver>>

Return a ChainObserver

pub async fn get_cardano_cli_runner(&mut self) -> Result<Box<CardanoCliRunner>>

Return a CardanoCliRunner

pub async fn get_immutable_file_observer( &mut self, ) -> Result<Arc<dyn ImmutableFileObserver>>

Return a ImmutableFileObserver instance.

pub async fn get_immutable_cache_provider( &mut self, ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>>

Get an ImmutableFileDigestCacheProvider

pub fn root_logger(&self) -> Logger

Return a copy of the root logger.

pub async fn get_transaction_repository( &mut self, ) -> Result<Arc<CardanoTransactionRepository>>

Transaction repository.

pub async fn get_chain_block_reader( &mut self, ) -> Result<Arc<Mutex<dyn ChainBlockReader>>>

Chain reader

pub async fn get_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>>

Block scanner

pub async fn get_immutable_digester( &mut self, ) -> Result<Arc<dyn ImmutableDigester>>

Immutable digester.

pub async fn get_snapshotter(&mut self) -> Result<Arc<dyn Snapshotter>>

Snapshotter service.

pub async fn get_certificate_verifier( &mut self, ) -> Result<Arc<dyn CertificateVerifier>>

CertificateVerifier service.

pub async fn get_genesis_verifier( &mut self, ) -> Result<Arc<ProtocolGenesisVerifier>>

Return a ProtocolGenesisVerifier

pub async fn get_mithril_registerer( &mut self, ) -> Result<Arc<MithrilSignerRegisterer>>

MithrilSignerRegisterer service

pub async fn get_era_reader(&mut self) -> Result<Arc<EraReader>>

EraReader service

pub async fn get_era_checker(&mut self) -> Result<Arc<EraChecker>>

EraReader service

pub async fn get_event_transmitter_sender( &mut self, ) -> Result<UnboundedSender<EventMessage>>

Return the EventMessage channel sender.

pub async fn get_event_transmitter_receiver( &mut self, ) -> Result<UnboundedReceiver<EventMessage>>

Return the channel receiver setup for the EventStore. Since this receiver is not clonable, it must be called only once.

pub async fn get_event_transmitter( &mut self, ) -> Result<Arc<TransmitterService<EventMessage>>>

TransmitterService service

pub async fn get_api_version_provider( &mut self, ) -> Result<Arc<APIVersionProvider>>

APIVersionProvider service

pub async fn get_stake_distribution_service( &mut self, ) -> Result<Arc<dyn StakeDistributionService>>

StakeDistributionService service

pub async fn get_signer_store(&mut self) -> Result<Arc<SignerStore>>

SignerStore service

pub async fn get_signable_builder_service( &mut self, ) -> Result<Arc<dyn SignableBuilderService>>

SignableBuilderService service

pub async fn get_signable_seed_builder( &mut self, ) -> Result<Arc<dyn SignableSeedBuilder>>

SignableSeedBuilder service

pub async fn get_signed_entity_service( &mut self, ) -> Result<Arc<dyn SignedEntityService>>

SignedEntityService service

pub async fn get_epoch_service(&mut self) -> Result<EpochServiceWrapper>

EpochService service

pub async fn get_signed_entity_storer( &mut self, ) -> Result<Arc<dyn SignedEntityStorer>>

SignedEntityStorer service

pub async fn get_single_signature_authenticator( &mut self, ) -> Result<Arc<SingleSignatureAuthenticator>>

SingleSignatureAuthenticator service

pub async fn get_metrics_service(&mut self) -> Result<Arc<MetricsService>>

MetricsService service

pub async fn create_usage_reporter(&mut self) -> Result<UsageReporter>

Create a UsageReporter instance.

pub async fn build_dependency_container( &mut self, ) -> Result<DependencyContainer>

Return an unconfigured DependencyContainer

pub async fn create_event_store(&mut self) -> Result<EventStore>

Create dependencies for the EventStore task.

pub async fn create_aggregator_runner(&mut self) -> Result<AggregatorRuntime>

Create the AggregatorRunner

pub async fn create_http_routes( &mut self, ) -> Result<impl Filter<Extract = (impl Reply,), Error = Rejection> + Clone>

Create the HTTP route instance

pub async fn create_cardano_transactions_preloader( &mut self, ) -> Result<Arc<CardanoTransactionsPreloader>>

Create a CardanoTransactionsPreloader instance.

pub async fn create_genesis_container( &mut self, ) -> Result<GenesisToolsDependency>

Create dependencies for genesis commands

pub async fn create_signer_importer( &mut self, cexplorer_pools_url: &str, ) -> Result<SignersImporter>

Create a SignersImporter instance.

pub async fn build_ticker_service(&mut self) -> Result<Arc<dyn TickerService>>

Create TickerService instance.

pub async fn get_ticker_service(&mut self) -> Result<Arc<dyn TickerService>>

StakeDistributionService service

pub async fn build_certifier_service( &mut self, ) -> Result<Arc<dyn CertifierService>>

Create CertifierService service

pub async fn get_certifier_service( &mut self, ) -> Result<Arc<dyn CertifierService>>

CertifierService service

pub async fn build_message_service(&mut self) -> Result<Arc<dyn MessageService>>

build HTTP message service

pub async fn get_message_service(&mut self) -> Result<Arc<dyn MessageService>>

MessageService service

pub async fn build_prover_service(&mut self) -> Result<Arc<dyn ProverService>>

Build Prover service

pub async fn get_prover_service(&mut self) -> Result<Arc<dyn ProverService>>

ProverService service

pub async fn vanish(self)

Remove the dependencies builder from memory to release Arc instances.