Struct Driver 

pub struct Driver {
    pub host: PersistHost,
    /* private fields */
}

Headless frontend to a clusterd replica.

Fields

host: PersistHost

Implementations

impl Driver

pub async fn connect(host: PersistHost, compute_addr: &str) -> Result<Self>

Connects to compute_addr, sends Hello, and starts the response pump. host provides persist + pubsub. The controller handshake proper (create_instance, update_configuration, InitializationComplete) is driven by the caller — see the script commands of the same name.

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

Drops the current connection and opens a new one, sending only Hello, so the caller can re-create_instance, replay the dataflows it expects the replica to be running, and then send InitializationComplete to close the reconciliation window.

Replacing sender drops the previous ComputeSender; with no other clones, the old pump task’s command channel closes and the pump exits, dropping the old CTP client and closing the old connection.

pub fn create_instance( &self, expiration_offset: Option<Duration>, arrangement_dictionary_compression: bool, ) -> Result<()>

Sends CreateInstance, opening the compute instance (and the reconciliation window).

expiration_offset and arrangement_dictionary_compression are the caller-settable InstanceConfig knobs; logging is left at its default (introspection logging off — enabling it safely needs index_logs wiring) and peek_stash_persist_location is necessarily the host’s, since the driver hosts persist.

This also force-disables ENABLE_PEEK_RESPONSE_STASH: the driver reads peek results inline, so a stashed peek would break Self::peek/count. It is patched here rather than exposed as a configuration knob, so a script’s update-configuration cannot turn it back on.

pub fn update_configuration(&self, dyncfg_updates: ConfigUpdates) -> Result<()>

Sends UpdateConfiguration with a set of dyncfg updates assembled by the caller. Generic over any configuration; the peek-response stash is not among them — it is force-disabled in Self::create_instance.

pub fn send(&self, cmd: ComputeCommand) -> Result<()>

Sends a raw ComputeCommand. The primitive behind every interaction; use cases drive side effects (AllowCompaction, CancelPeek, …) through this without the mechanism interpreting them.

pub fn submit_dataflow( &self, df: DataflowDescription<RenderPlan, CollectionMetadata>, ) -> Result<()>

Submits a dataflow. Does NOT schedule it — the caller decides when to schedule, so side-effect timing stays under test control.

pub fn schedule(&self, id: GlobalId) -> Result<()>

Schedules a previously-submitted collection, allowing it to make progress.

pub fn frontiers(&self, id: GlobalId) -> Receiver<FrontiersResponse>

A receiver for an id’s full merged frontiers, for use cases that need write/input frontiers rather than just output.

pub async fn expect_frontier( &self, id: GlobalId, target: Timestamp, timeout: Duration, ) -> Result<()>

Waits until id’s output frontier reaches at least target, or fails.

pub async fn peek( &self, target: PeekTarget, result_desc: RelationDesc, ts: Timestamp, ) -> Result<Vec<Row>>

Peeks target at ts, returning the decoded rows. The target is an index (served from the replica’s arrangement) or a persist collection — notably a materialized-view sink’s output shard, which is how SELECT * FROM mv reads. A persist peek blocks (async-friendly) until the shard seals through ts, so it doubles as a wait for the writing sink to catch up.

pub async fn peek_count( &self, target: PeekTarget, result_desc: RelationDesc, ts: Timestamp, ) -> Result<usize>

Convenience: total row count from a peek.

pub fn register_subscribe(&self, id: GlobalId)

Registers a subscribe-sink buffer for id, so the response pump accumulates its batches. Call this before scheduling the sink.

pub async fn await_subscribe( &self, id: GlobalId, up_to: Timestamp, timeout: Duration, ) -> Result<Vec<(Row, Timestamp, i64)>>

Waits until subscribe id’s upper frontier reaches at least up_to, then drains and returns its buffered (row, time, diff) updates. Fails on timeout or if the replica reported a subscribe error.