Struct Hydrant 

pub struct Hydrant {
    pub crawler: CrawlerHandle,
    pub firehose: FirehoseHandle,
    pub backfill: BackfillHandle,
    pub filter: FilterControl,
    pub repos: ReposControl,
    pub db: DbControl,
    pub backlinks: BacklinksControl,
    /* private fields */
}

the top-level handle to a hydrant instance.

Hydrant is cheaply cloneable. all sub-handles share the same underlying state. construct it via Hydrant::new or Hydrant::from_env, configure the filter and repos as needed, then call Hydrant::run to start all background components.

example

use hydrant::control::Hydrant;

#[tokio::main]
async fn main() -> miette::Result<()> {
    let hydrant = Hydrant::from_env().await?;

    tokio::select! {
        r = hydrant.run()?        => r,
        r = hydrant.serve(3000)  => r,
    }
}

Fields

crawler: CrawlerHandle

firehose: FirehoseHandle

backfill: BackfillHandle

filter: FilterControl

repos: ReposControl

db: DbControl

backlinks: BacklinksControl

Implementations

impl Hydrant

pub async fn new(config: Config) -> Result<Self>

open the database and configure hydrant from config.

this sets up the database, applies any filter configuration from config, and initializes all sub-handles. no background tasks are started yet: call run to start all components and drive the instance.

pub async fn from_env() -> Result<Self>

reads config from environment variables and calls Hydrant::new.

pub fn run(&self) -> Result<impl Future<Output = Result<()>>>

start all background components and return a future that resolves when any fatal component exits.

starts the backfill worker, firehose ingestors, crawler, and worker thread. resolves with Ok(()) if a fatal component exits cleanly, or Err(e) if it fails. intended for use in tokio::select! alongside serve.

returns an error if called more than once on the same Hydrant instance.

pub fn subscribe(&self, cursor: Option<u64>) -> EventStream

subscribe to the ordered event stream.

returns an EventStream that implements [futures::Stream].

• if cursor is None, streaming starts from the current head (live tail only).
• if cursor is Some(id), all persisted record events from that ID onward are replayed first, then live events follow seamlessly.

identity and account events are ephemeral and are never replayed from a cursor - only live occurrences are delivered. use ReposControl::get to fetch current identity/account state for a specific DID.

multiple concurrent subscribers each receive a full independent copy of the stream. the stream ends when the EventStream is dropped.

pub async fn stats(&self) -> Result<StatsResponse>

return database counts and on-disk sizes for all keyspaces.

counts include: repos, pending, resync, records, blocks, events, error_ratelimited, error_transport, error_generic.

sizes are in bytes, reported per keyspace.

pub fn serve(&self, port: u16) -> impl Future<Output = Result<()>>

returns a future that runs the HTTP management API server on 0.0.0.0:{port}.

the server exposes all management endpoints (/filter, /repos, /ingestion, /stream, /stats, /db/*, /xrpc/*). it runs indefinitely and resolves only on error.

intended for tokio::spawn or inclusion in a select! / task list. the clone of self is deferred until the future is first polled.

to disable the HTTP API entirely, simply don’t call this method.

pub fn serve_debug(&self, port: u16) -> impl Future<Output = Result<()>>

returns a future that runs the debug HTTP API server on 127.0.0.1:{port}.

exposes internal inspection endpoints (/debug/get, /debug/iter, etc.) that are not safe to expose publicly. binds only to loopback.

Trait Implementations

impl Clone for Hydrant

fn clone(&self) -> Hydrant

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl FromRef<Hydrant> for Arc<AppState>

fn from_ref(h: &Hydrant) -> Self

Converts to this type from a reference to the input type.