Struct Fake 

pub struct Fake {
    pub world: Arc<Mutex<World>>,
    pub store: MemStore,
}

The handle every backend trait is implemented on. Cheap to clone; all clones share one world and one journal store.

Fields

world: Arc<Mutex<World>>

store: MemStore

Implementations

impl Fake

pub fn footprint_view(&self, tools: &[UnitId]) -> FootprintView

§12d: the footprints as /run/planarian/footprint/ would hold them for the network tools tools, on the boot clock (seconds): the same planarian_backend_netwatch::FootprintView the Linux side reads.

pub fn new(world: World, store: MemStore) -> Fake

pub fn w(&self) -> MutexGuard<'_, World>

pub(crate) fn hung( &self, verb: &str, unit: &UnitId, wait: Millis, ) -> Option<Outcome>

hold_hangs: a hold call (systemctl start/stop, nft) that takes that long. Past wait the client gives up (Unknown, the fake clock advanced by wait) and nothing lands; within it, the call takes its time and goes on.

pub fn advance(&self, d: Millis)

pub(crate) fn admit(&self, w: &mut World, op: &OpId, call: String) -> bool

pub(crate) fn run( &self, op: &OpId, call: String, f: impl FnOnce(&mut World) -> Outcome, ) -> Outcome

One mutating backend call: fenced on a stale epoch before any effect (docs/assumptions.md), and subject to an injected outcome (World::inject, keyed by the call’s name before its parenthesis).

Trait Implementations

impl Backends for Fake

type Units = Fake

type Gens = Fake

Cloned onto a worker thread for the slow part of planning a change.

type Inv = Fake

type Probes = Fake

type Sessions = Fake

type Runtime = Fake

type Procs = Fake

type Clock = Fake

fn units(&self) -> &Fake

fn generations(&self) -> &Fake

fn inventory(&self) -> &Fake

fn probes(&self) -> &Fake

fn sessions(&self) -> &Fake

fn runtime(&self) -> &Fake

fn processes(&self) -> &Fake

fn clock(&self) -> &Fake

impl Clock for Fake

fn now(&self) -> Timestamp

The world’s now is elapsed time (boot time); the wall clock is it plus wall_skew, which only set_wall_clock moves (§12h).

fn boot_now(&self) -> Timestamp

Milliseconds on CLOCK_BOOTTIME: for everything that does not survive a reboot (approval tokens, leases, cooldowns, windows; §12h). Moving the wall clock never moves it.

fn sleep(&self, d: Millis)

impl Clone for Fake

fn clone(&self) -> Fake

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fake

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

Formats the value using the given formatter.

impl GenerationBackend for Fake

fn current(&self) -> Result<GenerationId, Outcome>

fn boot_entries(&self) -> Result<Vec<GenerationId>, Outcome>

fn boot_default(&self) -> Result<GenerationId, Outcome>

fn last_booted(&self) -> Result<GenerationId, Outcome>

fn created_by(&self, g: GenerationId) -> Option<(u32, Timestamp)>

Who created generation g and when (its profile link’s owner and time): the provenance of a rebuild made outside Planarian (§15).

fn stage( &self, _owner: &PinnedSource, overrides: &OverrideSet, ) -> Result<StagedSource, Outcome>

fn source_hash(&self, _owner: &PinnedSource) -> Result<Hash, Outcome>

Recompute the NAR hash of the owner’s Nix-visible source now (stale check, §9 step 6).

fn untracked(&self, _owner: &PinnedSource) -> Vec<String>

The owner’s files Nix cannot see now (untracked in a git flake), to report with the stale check: one added during the build was not there at staging (§9 step 1).

fn evaluate(&self, src: &StagedSource) -> Result<EvaluatedGeneration, Outcome>

fn build(&self, eval: &EvaluatedGeneration) -> Result<Built, Outcome>

Store-only; roots its own output.

fn dry_activation(&self, path: &StorePath) -> Result<ActivationPlan, Outcome>

What switching from the running generation to an existing one would start, stop, restart and reload (its dry activation), for SwitchGeneration / Revert / Rollback (§11, R04). An activation that failed, timed out or was cut short is an error, never a smaller plan.

fn override_content(&self, h: &Hash) -> Result<OverrideSet, Outcome>

The override content remember_override kept under this hash.

fn verify_candidate( &self, path: &StorePath, nar: Option<&Hash>, ) -> Result<bool, Outcome>

The path is a whole system, its contents still hash to what the store recorded, and, when nar is given (the transaction built it), that is the NAR hash recorded at build (§9 step 3, C6).

fn pending_jobs(&self) -> Result<Vec<JobId>, Outcome>

fn jobs_tagged(&self, op: &OpId) -> Result<Option<Vec<JobId>>, Outcome>

None: the backend cannot say whether work tagged with op exists.

fn override_hash(&self) -> Result<Hash, Outcome>

The override file’s current content hash (promotion compares against it, §9 step 4).

fn activate_live(&self, g: GenerationId, op: &OpId) -> Outcome

switch-to-configuration test.

fn publish_boot(&self, g: GenerationId, op: &OpId) -> Outcome

Boot entry only; no re-activation.

fn publish_boot_once( &self, g: GenerationId, keep: GenerationId, op: &OpId, ) -> Outcome

The boot-only path (§12 step 7, §12f): g boots once, at the next boot; keep stays the default. All or nothing.

fn one_shot_pending(&self) -> Result<Option<GenerationId>, Outcome>

The generation a one-shot entry will boot next, if one is pending.

fn protect(&self, g: GenerationId, op: &OpId) -> Outcome

fn cancel(&self, job: &JobId, op: &OpId) -> Outcome

fn swap_override(&self, from: &Hash, to: &Hash, op: &OpId) -> Outcome

Atomically replace the live override file with the content whose hash is to, but only if its current hash is from. Idempotent: if it already hashes to to, succeed without writing.

fn path_of(&self, g: GenerationId) -> Result<StorePath, Outcome>

The system store path of a known generation.

fn evaluate_built( &self, path: &StorePath, ) -> Result<EvaluatedGeneration, Outcome>

Evaluate an already-built generation from its store path (its exported manifest), for SwitchGeneration / Revert / Rollback.

fn read_overrides(&self) -> Result<(OverrideSet, Hash), Outcome>

The live override set and its content hash.

fn remember_override(&self, set: &OverrideSet) -> Result<Hash, Outcome>

Keep override content addressable by hash, so swap_override can write it.

fn override_for(&self, g: GenerationId) -> Result<Option<Hash>, Outcome>

The override content recorded for a generation when it was committed.

fn record_override(&self, g: GenerationId, hash: &Hash) -> Result<(), Outcome>

fn release_root(&self, root: &str) -> bool

Remove a GC root symlink this backend created.

fn collect_garbage( &self, protect: &[GenerationId], emergency: bool, op: &OpId, ) -> Outcome

Collect generations under the §12b bounds (gc::plan), never touching protect (I3), then collect store garbage. Mutating.

fn gc_plan( &self, protect: &[GenerationId], emergency: bool, ) -> Result<GcPlan, Outcome>

What collect_garbage would delete now. Read-only.

fn space_report(&self) -> Option<SpaceReport>

The last collection’s result.

fn age_out_build_roots(&self) -> Vec<String>

Remove build roots no transaction can still use: older than the longest a candidate may wait (§12f), a crashed build’s included. At startup and before every collection (§9 step 5, C4). Returns them.

impl InventoryBackend for Fake

fn devices(&self) -> Result<Vec<DeviceInfo>, Outcome>

fn resources(&self) -> Result<Resources, Outcome>

fn bound_driver(&self, device: &UnitId) -> Result<Option<DriverRef>, Outcome>

fn bind(&self, device: &UnitId, driver: &DriverRef, op: &OpId) -> Outcome

fn unbind(&self, device: &UnitId, op: &OpId) -> Outcome

impl ProbeBackend for Fake

fn run_batch(&self, jobs: &[(UnitId, ProbeDef)]) -> Vec<ProbeResult>

Run probes concurrently, each in its sandbox, each killed at its timeout (§10). One result per job, in order. FreeSpace probes are answered here too; SystemdActive and SessionTarget are evaluated by state.

impl ProcessBackend for Fake

fn kill_group(&self, pid: u32) -> bool

SIGTERM, then SIGKILL, the process group via pidfd; true once confirmed gone.

fn alive(&self, pid: u32) -> bool

impl RuntimeOptionBackend for Fake

fn get(&self, path: &str) -> Option<Value>

fn set(&self, path: &str, value: &Value, op: &OpId) -> Outcome

Outcome::Failed("no live mechanism") when the option can only be changed through its write-back.

fn alternatives(&self, path: &str) -> Vec<Value>

Other values the option could take right now (for wifi.network: known networks in range, besides the current one).

impl SessionBackend for Fake

fn sessions(&self) -> Result<Vec<SessionInfo>, Outcome>

fn compositor_running(&self, s: &SessionInfo) -> Option<bool>

Whether a compositor runs in this session’s own cgroup (§9); None if the backend cannot see.

fn foreground(&self) -> Vec<String>

Sessions in which foreground work holds (§10: a GameMode client, a gamescope session, …): Condition::Foreground.

fn power(&self) -> Option<PowerSource>

impl UnitBackend for Fake

fn protecting(&self, tools: &[UnitId]) -> Result<BTreeSet<UnitId>, Outcome>

§12d: the scripted footprints (footprint_view), read as the Linux side reads the files.

fn observe(&self, id: &UnitId) -> Result<Observed, Outcome>

fn ended_by(&self, id: &UnitId) -> Option<Ending>

How the unit’s main process last ended; None if the backend cannot say.

fn auto_restarts(&self, id: &UnitId) -> Option<u32>

How many times systemd itself restarted the unit (NRestarts); None if the backend cannot say.

fn foreign_units(&self) -> Vec<String>

The boot report’s unit check (§10): active units whose definition does not come from the running generation (a file outside the store that is not a generator’s).

fn list(&self) -> Result<Vec<UnitId>, Outcome>

fn start_agent( &self, name: &str, _argv: &[String], _limits: &AgentLimits, ) -> Result<InstanceId, Outcome>

Start an agent (§11, §16): the transient unit planarian-agent-<name>, under a dynamic uid of its own. Returns the started unit’s instance (its InvocationID), read back once it has started (I24).

fn agent_running(&self, name: &str) -> bool

Whether an agent’s unit under this name is loaded and running (I24: agent run refuses a name in use).

fn hold(&self, unit: &UnitId, wait: Millis) -> Outcome

§12d Network security fails closed: hold the traffic a failed network-security unit protected (planarian-hold@<unit>). A failure posture response, not a transition: no Prepared, no lease (it only ever restricts traffic; docs/bypasses.md). Idempotent. Unlike the other mutations here it takes no OpId; the daemon journals HoldApplied before calling it.

fn lift_hold(&self, unit: &UnitId, wait: Millis) -> Outcome

Lift a unit’s hold, once it is Running and its Readiness probes pass (journaled HoldLifted first). Idempotent. At most wait.

fn held(&self) -> Result<BTreeSet<UnitId>, Outcome>

The units whose traffic is held now, as the host says (§12d: the hold survives a restart of planariad). An error means “cannot say”, never “none”.

fn release_hold( &self, unit: &UnitId, until: Option<Timestamp>, wait: Millis, ) -> Outcome

planarian hold release (an attested Override, decided before this): mark the unit’s hold released until until (None: the next boot), then lift it, waiting at most wait. While the mark stands, a new failure does not hold.

fn end_release(&self, unit: &UnitId) -> Outcome

The release ended (expired, or the override lifted): remove the mark.

fn hold_table_present(&self, wait: Millis) -> Result<bool, Outcome>

Whether the hold’s nftables table is in place. Anything else that flushes the ruleset (nft flush ruleset) removes it and would fail open; the daemon checks this while a hold is active. An error means “cannot say” (also past wait).

fn reapply_hold(&self, unit: &UnitId, wait: Millis) -> Outcome

Build a unit’s hold again (the table was removed under it): restart its hold unit, since starting an active one does nothing. At most wait.

fn restart(&self, id: &UnitId, op: &OpId) -> Outcome

fn stop(&self, id: &UnitId, op: &OpId) -> Outcome