Struct StoreCoordinator 

pub struct StoreCoordinator<S: CoordinationStore + Clone> { /* private fields */ }

A SplitCoordinator over any CoordinationStore.

Built with a multi-thread runtime handle (the background task and the store’s I/O live there; a current-thread runtime would deadlock the blocking replies and is rejected at construction).

Implementations

impl<S: CoordinationStore + Clone> StoreCoordinator<S>

pub fn new( store: S, config: CoordinationConfig, io: Handle, metrics: Option<CoordinationMetrics>, ) -> Result<StoreCoordinator<S>, CoordinationError>

Wrap a store. io must be a multi-thread runtime handle.

Errors

Fatal on invalid configuration, a current-thread runtime, or a store whose lease TTL diverges from config.lease_duration.

pub fn instance_id(&self) -> &str

This worker’s (stable or generated) instance id.

Trait Implementations

impl<S: CoordinationStore + Clone> Debug for StoreCoordinator<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: CoordinationStore + Clone> Drop for StoreCoordinator<S>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<S: CoordinationStore + Clone> SplitCoordinator for StoreCoordinator<S>

fn start( &mut self, planner: Box<dyn SplitPlanner>, ) -> Result<(), CoordinationError>

Join the job: verify the fingerprint, hand over this worker’s planner (used only if and while this instance is elected leader), and start the backend’s claim and renewal machinery. Called exactly once, before any other method.

fn set_waker(&mut self, waker: ControlWaker)

Hand the backend the handle it signals when it has events to deliver. Called once, before start.

fn poll(&mut self) -> Result<Vec<CoordinationEvent>, CoordinationError>

Ownership and job-state changes since the last call. Must not block — return whatever is pending, including nothing. The driver parks on the ControlWaker instead.

fn commit( &mut self, split: &SplitId, progress: &SplitProgress, ) -> Result<(), CoordinationError>

Fenced durable commit of one owned split’s progress. Ok means durable. Fenced means the split is no longer owned and nothing was written — stop the split, never retry the write. Retryable leaves the previous committed state authoritative; re-committing the merged progress on the next tick is idempotent.

fn fail( &mut self, split: &SplitId, reason: &str, ) -> Result<(), CoordinationError>

Report an owned split as unprocessable by this tenancy: consumes one delivery attempt and releases it for another worker to retry. At the backend’s attempt cap the split is quarantined instead (CoordinationEvent::Quarantined). Use for poison input; a transient local problem is better handled by release, which consumes nothing.

fn release(&mut self, splits: &[SplitId]) -> Result<(), CoordinationError>

Voluntarily hand back owned splits (shutdown, scale-down) so peers claim them without waiting out a lease. Consumes no delivery attempts. Best-effort and idempotent; splits not released simply expire.

fn release_drained( &mut self, splits: &[SplitId], ) -> Result<(), CoordinationError>

Release splits given up through a cooperative revocation — the owner has drained each split, committed its tail, and is now handing it back. Semantically a release (attempt-free, best-effort, idempotent), but distinguished so a revocation-aware backend can record the drain as having completed and never mistake a single-split revocation for a departure from the fleet.

fn decline_revoke(&mut self, split: &SplitId) -> Result<(), CoordinationError>

Decline a RevokeRequested the embedder cannot serve — the source refused to stop the split’s intake, or the split is not in a drainable state.