Struct Indexer 

pub struct Indexer { /* private fields */ }

Top-level orchestrator. Wraps a framework::Indexer over the Store for RpcStoreSchema together with a [Synchronizer] coordinating cross-pipeline snapshots, and exposes the per-pipeline registration shape this crate needs.

Construct one of two ways:

• Indexer::new opens the [Db] / Store internally — typical for the standalone binary path.
• Indexer::from_store takes an already-opened Store — typical for the embedded-fullnode path where the fullnode shares the underlying database with this indexer for direct reads (and possibly for its own raw-chain-data writes).

Pipelines are registered through Self::add_pipelines, which honours the per-pipeline enable/disable knobs encoded in a PipelineLayer. Disabled pipelines are skipped entirely — the [Synchronizer] only barriers across pipelines that were actually registered, so leaving the raw-chain-data pipelines off does not stall snapshots.

After pipelines are registered, Self::run installs the synchronizer onto the store and starts the framework indexer.

Implementations

impl Indexer

pub async fn new( path: impl AsRef<Path>, indexer_args: IndexerArgs, ingestion_client: IngestionClient, streaming_client: Option<BoxedStreamingClient>, consistency_config: ConsistencyConfig, pruner_config: Option<PrunerConfig>, ingestion_config: IngestionConfig, db_options: DbOptions, registry: &Registry, ) -> Result<Self>

Open the database at path with RpcStoreSchema and construct an Indexer backed by it.

ingestion_client is the pull-side checkpoint source; the optional streaming_client is the live-tail source. Callers (standalone binary, embedded fullnode) build the IngestionClient via IngestionClient::new (driven by ClientArgs) or IngestionClient::from_trait (wrapping a custom IngestionClientTrait), depending on where checkpoints come from. The IngestionMetrics handle the service shares with the client is reused from IngestionClient::metrics, avoiding double-registration against registry.

pub async fn from_store( store: Store, indexer_args: IndexerArgs, ingestion_client: IngestionClient, streaming_client: Option<BoxedStreamingClient>, consistency_config: ConsistencyConfig, pruner_config: Option<PrunerConfig>, ingestion_config: IngestionConfig, registry: &Registry, ) -> Result<Self>

Variant of Self::new that takes an already-opened Store. Useful when the caller wants to share the underlying [Db] with other code in the same process (e.g. a fullnode that reads through RpcStoreSchema directly, or writes to the raw-chain-data CFs through a separate path).

pub fn store(&self) -> &Store

Borrow the wrapped framework indexer’s store. Useful for embedded callers that want a read handle pointed at the same RpcStoreSchema this orchestrator is writing to.

pub fn pipelines(&self) -> impl Iterator<Item = &'static str> + '_

Iterate over the names of every pipeline that has been registered with this indexer and is enabled (i.e. not filtered out by IndexerArgs::pipeline). Useful for asserting which pipelines are active before Self::run is called.

pub async fn add_pipelines( &mut self, layer: PipelineLayer, committer: CommitterConfig, ) -> Result<()>

Register every pipeline that is Some(_) in layer. The supplied CommitterConfig acts as the shared base; each pipeline’s CommitterLayer overrides individual fields.

Skipped (None) pipelines are not registered with the [Synchronizer] either, so its snapshot barrier still proceeds without them.

pub async fn add_checkpoint_broadcast( &mut self, sender: Sender<Arc<Checkpoint>>, committer: CommitterConfig, ) -> Result<()>

Register the checkpoint-broadcast pipeline, which re-publishes each committed checkpoint to sender in checkpoint order (see checkpoint_broadcast). Call alongside Self::add_pipelines and before Self::run.

Kept separate from Self::add_pipelines because it carries a runtime broadcast::Sender rather than a PipelineLayer toggle — only the standalone sui-rpc-node, which hosts the subscription service, registers it; the embedded fullnode feeds its subscription service from the checkpoint executor instead.

As with every synchronizer-coordinated pipeline, registers with max_batch_checkpoints = 1 so each commit (and thus each broadcast) is exactly one checkpoint.

pub async fn run(self) -> Result<Service>

Install the synchronizer onto the store and start the framework indexer. Returns a composed Service handle that drives both for the lifetime of the indexer.