Struct ReloadablePolicy 

pub struct ReloadablePolicy { /* private fields */ }

A hot-reloadable Policy holder for the enforcement point: the active policy can be swapped at runtime (e.g. when the policy file changes) without a restart, while readers keep the coarse evaluate path lock-light.

It wraps an Arc<Policy> behind an RwLock. Per request the guard calls current — a brief read-lock returning a cheap Arc clone it then evaluates against; a reload calls store — a brief write-lock swapping the Arc. A request in flight during a reload finishes against the snapshot it took, so a swap is never observed mid-evaluation. Poison-safe: a panic elsewhere never makes current/store panic (verifier rule: no panics in the API).

The trigger (a file-mtime watch, a signal, an admin endpoint) is the service’s concern — this type only holds and swaps the value.

Implementations

impl ReloadablePolicy

pub fn new(policy: Policy) -> Self

Wrap an initial policy (e.g. the one loaded at boot).

pub fn current(&self) -> Arc<Policy>

The currently active policy — a cheap Arc clone taken under a brief read-lock. Evaluate against the returned snapshot; a concurrent store does not affect it.

pub fn store(&self, policy: Policy)

Atomically replace the active policy (a brief write-lock). New requests see the new policy; in-flight requests finish against the snapshot they already took.

Trait Implementations

impl Debug for ReloadablePolicy

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

Formats the value using the given formatter.