Struct Hydrant 

pub struct Hydrant {
    pub crawler: CrawlerHandle,
    pub firehose: FirehoseHandle,
    pub backfill: BackfillHandle,
    pub filter: FilterControl,
    pub pds: PdsControl,
    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

pds: PdsControl

repos: ReposControl

db: DbControl

backlinks: BacklinksControl

Implementations

impl Hydrant

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 the stream will switch to live tailing.

identity and account events are ephemeral and are never replayed from a cursor, only live ones are delivered. use ReposControl::info to fetch current state for a specific repository.

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

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 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.). binds only to loopback.

pub async fn get_host_status(&self, hostname: &str) -> Result<Option<Host>>

get the status of a (firehose) host we are consuming from.

returns the seq we are on for this host.

pub async fn list_hosts( &self, cursor: Option<&str>, limit: usize, ) -> Result<(Vec<Host>, Option<SmolStr>)>

enumerates all hosts hydrant is consuming from.

returns hosts enumerated in this pagination and the cursor to paginate from.

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.