Struct LiveOperationGuard 

pub struct LiveOperationGuard { /* private fields */ }

A held OS lock paired with the conditional SQLite owner/claim and an independent five-second heartbeat. Dropping it releases the OS lock; successful completion must call Self::release so the database owner and claim are also durably retired.

Implementations

impl LiveOperationGuard

pub async fn acquire( pool: &SqlitePool, run_id: Option<i64>, operation_kind: LiveOperationKind, bridge_host: &str, server: &str, resource_tag: &str, restore_intent_json: Option<String>, ) -> Result<Self, LiveOwnershipAcquireError>

Acquires the OS lock first, then creates the owner and atomically claims its canonical database/controller/tag key. Recovery uses a separate transaction that also starts the recovery attempt and records its evidence.

pub async fn acquire_for_recorded_run( pool: &SqlitePool, run: &TuneRunRow, operation_kind: LiveOperationKind, restore_intent_json: String, ) -> Result<Self, LiveOwnershipAcquireError>

Acquires ownership for a post-run write or revert using only the connection and MV recorded on run. Explicit caller values must be cross-checked before this function; they are never used to select a different controller.

pub async fn try_acquire_database_file( pool: &SqlitePool, ) -> Result<Option<DatabaseFileGuard>>

Returns a database-file guard without creating a database owner. Full-mode startup uses this to distinguish a stale heartbeat from a still-running, possibly paused owner.

pub fn owner(&self) -> &LiveOwnershipRow

pub fn claim_key(&self) -> &str

pub fn database_key(&self) -> &str

pub fn ensure_healthy(&self) -> Result<()>

Prevents a caller from starting another controller mutation after an asynchronous database-heartbeat failure. An already-issued driver call remains protected by the OS lock until its owning future finishes or the process exits.

pub async fn queue_previous_write_value(&self, tag: &str, value_json: String)

Queues the value observed before the next write to tag. The audited driver consumes it when it records the write intent, preserving correct pre-write data even for write-and-rollback sequences on the same tag.

pub async fn clear_previous_write_values(&self)

pub async fn persist_restore_intent(&self, intent_json: &str) -> Result<()>

Replaces the pre-mutation recovery intent with a more complete, durably persisted snapshot. Failure prevents the caller from issuing its next live write.

pub async fn release(self) -> Result<()>

Retires the persisted owner/claim before releasing the OS lock. A database persistence failure is returned to the caller and must never be reported as successful completion.

pub async fn stop_heartbeat(&mut self)

Stops heartbeat updates while a recovery attempt atomically finalizes both owners and the claim. The caller must keep this guard alive until that transaction succeeds or fails.

Trait Implementations

impl Drop for LiveOperationGuard

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.