Struct LiveConfigAuthority 

pub struct LiveConfigAuthority { /* private fields */ }

The live configuration state shared by one supervised daemon generation.

The write lock is deliberately paired with the published-config storage so every mutation path uses the same serialization witness as the live state. The published pair (config plus its opaque revision) lives in zeroclaw_config::live; this authority owns who may publish and when.

Readers receive LiveConfigHandle through Self::live_handle; the writable storage is never exposed. Writers admit through Self::begin_config_commit, which serializes on the writer mutex and admits a generation write lease as one unit.

Implementations

impl LiveConfigAuthority

pub fn new(config: Config) -> Self

Create the authority for one daemon generation. The initial config is the first publication of a fresh epoch.

pub fn new_owned(config: Config) -> Result<Self>

Create an authority that exclusively owns this config across processes.

pub fn new_with_ownership( config: Config, ownership: ConfigOwnershipGuard, ) -> Self

Create an authority from a guard acquired by a caller that resolved the config identity before loading the executable config. The guard is transferred into the authority and shared by every derived capability. The loaded config becomes the initial publication of a fresh epoch: a full daemon reload is a new publication domain, never a continuation of the retired generation’s sequence.

pub fn live_handle(&self) -> LiveConfigHandle

Return the read-only live-config handle shared by all consumers of this authority. The handle observes the config and its revision as one pair and exposes no write path.

pub fn snapshot_config(&self) -> Config

Clone the currently published config.

pub fn published_revision(&self) -> ConfigRevision

The currently published revision.

pub fn application_status(&self) -> ConfigApplicationStatus

Application facts for the daemon, without exposing RPC sessions.

pub fn config_epoch(&self) -> ConfigEpoch

The epoch of this authority’s publication domain. Cloned authorities share it; a full replacement authority does not.

pub async fn begin_config_commit( &self, ) -> Result<ConfigCommit, ConfigCommitError>

Admit one serialized config write: acquire the process-wide writer mutex, then admit a generation write lease into the lifecycle generation. The returned ConfigCommit owns both for its whole lifetime, so a commit dispatched to a retained task keeps serialization and stays drain-visible even when its requester disappears.

Admission fails closed once the generation is closing. The writer mutex is acquired before the lease: a waiter parked on the mutex holds no lifecycle state, so a closing generation never drains against a waiter that will simply be refused.

pub async fn lock_config_writer(&self) -> OwnedMutexGuard<()>

Hold this authority’s config writer mutex without admitting a commit. Readers in the route-generation transaction (session construction, session/configure, rehydration and its reconciliation) take it so that no commit publishes while they build from config. It admits no write lease, so a closing generation never drains against a reader.

pub fn try_lock_config_writer(&self) -> Option<OwnedMutexGuard<()>>

Self::lock_config_writer without waiting: None while a commit or another reader holds the mutex.

pub fn agent_lifecycle(&self) -> AgentLifecycleCoordinator

Return the alias-scoped lifecycle authority shared by this daemon run.

pub fn execution_capability(&self) -> AgentExecutionCapability

Bind target execution admission to this authority’s live config and alias lifecycle coordinator. Callers keep the returned capability and pass it into the target factory or detached task; it is not a registry and does not create another config owner.

pub fn close_agent_lifecycle(&self)

Close lifecycle admission for this daemon generation. New agent work and new config commits are both refused afterwards; already-admitted work runs to completion and is drained by the drain methods below.

pub async fn drain_agent_lifecycle(&self)

Drain a closed generation and release its process ownership.

pub async fn drain_agent_lifecycle_retaining_ownership(&self)

Drain a closed generation while RETAINING process ownership, so a daemon reload can transfer the guard into the next generation without an unlocked read/reacquire interval. Pair with Self::take_process_ownership once the drain completes.

pub fn take_process_ownership(&self) -> Option<ConfigOwnershipGuard>

Transfer the process-ownership guard out of this authority. Returns None when ownership was already released by a completed drain or never acquired.

Trait Implementations

impl Clone for LiveConfigAuthority

fn clone(&self) -> LiveConfigAuthority

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.