Struct Work 

pub struct Work<N, B, P> {
    pub metadata: N,
    pub purge: Option<PurgeConfig>,
    pub serving: B,
    pub preserved: P,
    pub root: Partition,
    pub shards: Arc<dyn ShardMap>,
    pub addressing: Addressing,
    pub retention_ms: u64,
    pub discovery_margin_ms: u64,
    pub profile: Profile,
    pub clock: Arc<dyn Clock>,
}

All runtime dependencies; preservation is a separately provisioned blob store.

Fields

metadata: N

purge: Option<PurgeConfig>

Automatic cache purge settings shared with signed and late intake.

serving: B

preserved: P

root: Partition

shards: Arc<dyn ShardMap>

addressing: Addressing

retention_ms: u64

discovery_margin_ms: u64

profile: Profile

clock: Arc<dyn Clock>

Implementations

impl<N: NamespaceStore + Clone, B: BlobStore, P: BlobStore> Work<N, B, P>

pub async fn plan_legal_hold<S: NamespaceStore>( &self, store: &S, id: Hash, enabled: bool, now: u64, ) -> Result<Batch, StoreError>

Prepare guarded legal-hold state for the signed admin framework. Commit with the operator’s audit and replay result; no public route exists yet.

Errors

Unknown requests, ended purge ownership, storage errors or invalid retention.

Trait Implementations

impl<N: NamespaceStore + Clone, B: BlobStore, P: BlobStore> AdminOperations for Work<N, B, P>

fn preserved_now_ms(&self) -> Result<i64, ServerError>

Backend time for terminal preserved-stream failure audits.

fn plan<'a>( &'a self, path: &'a str, input: &'a Json, digest: &'a str, now: u64, budget: &'a SliceBudget, ) -> BoxFuture<'a, Result<Prepared, ServerError>>

Prepare root effects after staging immutable action metadata; no denial is activated here.

fn after_commit<'a>( &'a self, path: &'a str, input: &'a Json, response: Response, now: u64, budget: &'a SliceBudget, ) -> BoxFuture<'a, Result<Response, ServerError>>

Resume accepted denial activation from durable validated metadata. Called on nonce and operation replay as well as first acceptance.

fn preserved_piece<'a>( &'a self, descriptor: &'a Json, ) -> BoxFuture<'a, Result<PreservedPiece, ServerError>>

Read one bounded, freshly authorized and verified preservation piece. The input is a byte-free descriptor; implementations recheck live retention.

impl<N, B, P> Debug for Work<N, B, P>

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

Formats the value using the given formatter.

impl<S: NamespaceStore, N: NamespaceStore + Clone, B: BlobStore, P: BlobStore> TimerHandler<S> for Work<N, B, P>

fn kind(&self) -> TimerKind

The kind this handler decodes.

fn max_per_tick(&self) -> Option<u32>

Lowers the shared TickBudget::max_per_kind allowance for this kind.

fn fire<'a>( &'a self, ctx: &'a TimerCtx<'a, S>, timer: &'a DueTimer, ) -> BoxFuture<'a, Result<Fired, StoreError>>

Prepare effects; the core atomically guards and removes the timer.