Struct EpochFencedReload 

pub struct EpochFencedReload { /* private fields */ }

Orchestrator for an atomic plugin reload — implements the proposal’s §11.2 epoch-fenced cutover.

The reload protocol:

1. The host calls EpochFencedReload::begin_drain on the old plugin’s lifecycle. The state advances Active → Draining. New operations no longer capture the old plugin; in-flight ops that already captured an Arc<dyn ScalarPluginFn> continue against the old instance.
2. The host invokes the load path for the new plugin and walks its lifecycle Loaded → Linked → Initialized → Active.
3. The host calls EpochFencedReload::wait_for_drain, polling Arc::strong_count on the old plugin’s lifecycle. When the only outstanding reference is the framework’s bookkeeping Arc, every in-flight operation against the old plugin has completed.
4. The host advances the old plugin’s lifecycle to Removed via EpochFencedReload::finalize.

The driver is decoupled from per-kind reload discipline (per proposal §11.2.1) — that lives in the host’s storage / index / background-job specific code. This driver provides the general state-machine orchestration.

EpochFencedReload is intentionally synchronous (no async fn) so it can be called from any context. For long-drain scenarios (e.g., 10s wall-clock queries against a storage backend), the host wraps the polling loop in its own async runtime.

Implementations

impl EpochFencedReload

pub fn new(old: Arc<PluginLifecycle>) -> Self

Construct a driver for an old-plugin lifecycle.

pub fn begin_drain(&self) -> Result<(), DrainError>

Begin draining the old plugin. Advances state Active → Draining.

Errors

Returns Err if the old plugin is not in Active state — the caller can choose to retry or bail out depending on policy.

pub fn wait_for_drain( &self, threshold: usize, poll_interval: Duration, max_wait: Duration, ) -> Result<(), DrainError>

Wait until the old plugin has been fully drained.

Polls Arc::strong_count(&self.old) with the supplied poll interval. Returns when the count drops to threshold (the number of bookkeeping Arcs the framework holds), or Err(DrainError::Timeout) if max_wait elapses first.

threshold is typically 1 (just the framework’s own EpochFencedReload::old Arc); pass 2 if the host also keeps a side reference for diagnostics.

Errors

Returns DrainError::Timeout if the strong-count doesn’t drop to threshold within max_wait.

pub fn finalize(&self)

Finalize the drain — advance to Removed.

Typically called only after Self::wait_for_drain succeeds. Safe to call multiple times (idempotent at Removed).

pub fn old_lifecycle(&self) -> &Arc<PluginLifecycle>

Shared access to the old plugin’s lifecycle (e.g., for observability hooks reading the current state).

Trait Implementations

impl Debug for EpochFencedReload

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

Formats the value using the given formatter.