Struct Jobs 

pub struct Jobs {
    config: JobConfig,
    ops: Mutex<HashMap<String, Arc<OpControl>>>,
    active: Mutex<usize>,
    slot_freed: Condvar,
}

The ops in flight, and the slots they take turns on.

Fields

config: JobConfig

ops: Mutex<HashMap<String, Arc<OpControl>>>

active: Mutex<usize>

slot_freed: Condvar

Implementations

impl Jobs

pub fn new(config: JobConfig) -> Self

fn protected(&self) -> ProtectedPaths

pub fn start( self: &Arc<Self>, req: &FsOpStartReq, emit: Arc<dyn Fn(&FsOpEvent) + Send + Sync>, ) -> Result<FsOpStartResult, String>

fs.op.start: validate, then run in the background. Blocking (it stats and canonicalizes), so call it from spawn_blocking.

pub(super) fn start_host( self: &Arc<Self>, kind: FsOpKind, requested: usize, dest: String, emit: Arc<dyn Fn(&FsOpEvent) + Send + Sync>, work: Box<dyn FnOnce(&mut HostJob<'_, '_>) -> Result<(), HostStop> + Send>, ) -> Result<FsOpStartResult, String>

Run work as an op of kind in this registry, the way Self::start runs a local one: its own thread, a slot, cancel and conflict answers through fs.op.cancel and fs.op.resolve, progress as files:op events, and the audit line at the end (dest and requested are for it). For transfers that touch an SSH host (host_jobs).

pub fn resolve( &self, op_id: &str, choice: FsOpChoice, apply_to_all: bool, ) -> Result<(), String>

fs.op.resolve. Only an op blocked on a conflict takes an answer: one stored ahead of time would silently decide whatever conflict came next.

pub fn cancel(&self, op_id: &str)

fs.op.cancel. Wakes the op whether it is copying, waiting on a conflict or queued for a slot. Unknown or finished ops are ignored.

fn take_slot(&self, control: &OpControl) -> Option<Slot<'_>>

Block until a slot is free, or return None if canceled first.

fn run( self: Arc<Self>, op_id: String, plan: Plan, control: Arc<OpControl>, emit: Arc<dyn Fn(&FsOpEvent) + Send + Sync>, )

The op’s thread. Its registry entry and slot are released by guards, so they go however the op ends, a panic included.